Adding two strings made of digits recursively in C - c

Question

For this problem, I am to first take in two strings using fgets. I then need to check if the string is comprised entirely of digits thus making it a number. I was able to do this part recursively, but the next task is if the strings are numbers, I need to sum them up recursively as well. So for example,
the output of the program may look something like this:
First number > 9023905350290349
Second number > 90283056923840923840239480239480234
Sum is 90283056923840923849263385589770583
Again, I need to do this recursively, so I was thinking I could march along the stream of digits and add them together, but I am not so sure how to write this program recursively. Also since the input is in character form, I would also have to convert it to an integer, which I believe I can do by converting the individual characters to the integer ASCII value then subtracting 48 away from it. Any help would be appreciated. Thanks!

Answer 1

You're on the right track. Your recursive approach to checking if the input is a number looks something like the following, right? Notice that you can go ahead and subtract '0' from a character without bothering to convert it to 48 yourself.
int number_length(char *s, int pos) {
int d;
if (s[pos] == '\0') {
return pos;
}
d = s[pos] - '0';
if (d < 0 || d > 9) {
return -1;
}
return number_length(s, pos+1);
}
The above function returns -1 if the input is invalid, and the length of the number otherwise. We can use the length of the input numbers when we start the recursive addition process.
Where should the recursion begin? When we add a pair of numbers, it is convenient to start from the least significant digits.
If we have a pair of char * variables a and b pointing to the numbers, and if we know that a contains a_length digits and b contains b_length digits, then:
The least significant digit of a is at a_length-1.
The least significant digit of b is at b_length-1.
We don't know in advance how long the result is going to be, so let's build up the digits in an int * array starting from position 0. This means that we'll have the result digits in reverse, so we'll print them out starting from the end and going back to 0.
The core of the computation is this:
Given a position a_pos in a and b_pos in b, as well as a carry digit carry, compute the sum of the digits in a and b together with the carry digit.
Update the carry digit.
Add the result digit to the result array and update the length of the array.
In C, we can express the computation as follows:
d = a[a_pos--] + b[b_pos--] - 2*'0' + carry;
carry = (d >= 10 ? 1 : 0);
result[result_pos++] = d%10;
The expression a[a_pos--] + b[b_pos--] becomes invalid once a_pos or b_pos has become negative. In other words, we must deal with situations where we have run out of digits in one or both numbers. We must take care to:
Handle cases where we've already processed the most significant digit of a but not b, or b but not a.
When we've reached the end of both a and b, remember to check the carry digit: if it's 1, add it to the result and increment the length of the result.
Below is a complete implementation in ANSI C.
#include <stdio.h>
#include <string.h>
#define BUFFER_SIZE 8192
char a[BUFFER_SIZE], b[BUFFER_SIZE];
int result[BUFFER_SIZE];
int number_length(char *s, int pos) {
int d;
if (s[pos] == '\0') {
return pos;
}
d = s[pos] - '0';
if (d < 0 || d > 9) {
return -1;
}
return number_length(s, pos+1);
}
int add(char *a, int a_pos, char *b, int b_pos,
int *result, int result_pos, int carry) {
int d;
if (a_pos < 0 && b_pos < 0) {
if (carry == 1) {
result[result_pos++] = 1;
}
return result_pos;
}
if (a_pos < 0) {
result[result_pos++] = b[b_pos--] - '0' + carry;
carry = 0;
} else if (b_pos < 0) {
result[result_pos++] = a[a_pos--] - '0' + carry;
carry = 0;
} else {
d = a[a_pos--] + b[b_pos--] - 2*'0' + carry;
carry = (d >= 10 ? 1 : 0);
result[result_pos++] = d%10;
}
return add(a, a_pos, b, b_pos, result, result_pos, carry);
}
int main() {
int a_length, b_length, i, result_length;
printf("First number > ");
scanf("%s", a);
if ((a_length = number_length(a, 0)) == -1) {
printf("%s is not a number.\n", a);
return 0;
}
printf("Second number > ");
scanf("%s", b);
if ((b_length = number_length(b, 0)) == -1) {
printf("%s is not a number.\n", b);
return 0;
}
result_length = add(a, a_length-1, b, b_length-1, result, 0, 0);
for (i = result_length-1; i >= 0; --i) {
printf("%d", result[i]);
}
printf("\n");
return 0;
}

Answer 2

UPDATE: the comment below made me realize that I've obviously misunderstood the question. My previous solution of course wouldn't have worked with huge numbers like the ones in the OP's question. I've updated my answer accordingly as "right to left" approach. The only problem is that the resulting string can have a leading zero...
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void add_helper(const char *s1, const char *s2, int s1_pos, int s2_pos,
char *result, int pos, int carry) {
int d1 = 0;
int d2 = 0;
if (s1_pos >= 0) {
d1 = s1[s1_pos] - '0';
s1_pos--;
}
if (s2_pos >= 0) {
d2 = s2[s2_pos] - '0';
s2_pos--;
}
int d = d1 + d2 + carry;
carry = d > 9 ? 1 : 0;
result[pos] = '0' + (d % 10);
pos--;
if (s1_pos >= 0 || s2_pos >= 0)
add_helper(s1, s2, s1_pos, s2_pos, result, pos, carry);
else if (pos >= 0)
result[pos] = '0' + carry;
}
char *add_recurse(const char *s1, const char *s2) {
size_t s1_len = strlen(s1);
size_t s2_len = strlen(s2);
size_t result_len = (s1_len > s2_len ? s1_len : s2_len) + 1;
char *result = calloc(result_len, 1);
add_helper(s1, s2, s1_len-1, s2_len-1, result, result_len - 1, 0);
return result;
}
int main(int argc, char **argv)
{
char *num_str1 = "9023905350290349";
char *num_str2 = "90283056923840923840239480239480234";
printf("sum is %s\n", add_recurse(num_str1, num_str2));
}
Note that there is no error handling whatsoever and I assume the preconditions, that the input strings are valid strings consisting of only digits, which you said you have already checked it.
ADDED SINGLE PASS VERSION (for Jean-Baptiste Yunès, who considers the usage of 'strlen' a little bit cheating...):
int add_helper2(const char *s1, const char *s2, int acc1, int acc2,
int *s1_pos, int *s2_pos, int *pos, char **result) {
int carry = 0;
int d1 = 0;
int d2 = 0;
if (s1[acc1] || s2[acc2]) {
int t1 = (s1[acc1] != 0);
int t2 = (s2[acc2] != 0);
carry = add_helper2(s1, s2, acc1+t1, acc2+t2, s1_pos,
s2_pos, pos, result);
} else {
size_t result_len = (acc1 > acc2 ? acc1 : acc2) + 1;
*result = calloc(result_len, 1);
*s1_pos = acc1 - 1;
*s2_pos = acc2 - 1;
*pos = result_len - 1;
return 0;
}
if (*s1_pos >= 0) {
d1 = s1[*s1_pos] - '0';
*s1_pos -= 1;
}
if (*s2_pos >= 0) {
d2 = s2[*s2_pos] - '0';
*s2_pos -= 1;
}
int d = d1 + d2 + carry;
carry = d > 9 ? 1 : 0;
(*result)[*pos] = '0' + (d % 10);
*pos -= 1;
return carry;
}
char *add_recurse2(const char *s1, const char *s2) {
char *result;
int s1_pos, s2_pos, pos;
int carry = add_helper2(s1, s2, 0, 0, &s1_pos, &s2_pos, &pos, &result);
result[0] = '0' + carry;
return result;
}

Answer 3

Make it in a single recursive descent is not so easy, but this can make it :
char n1[] = "9023905350290349";
char n2[] = "90283056923840923840239480239480234";
char n3[1000];
char addchar(char c,char d,int r) {
return ((c-'0')+(d-'0')+r)%10 + '0';
}
int overflow(char c,char d,int r) {
return ((c-'0')+(d-'0')+r)/10;
}
int d;
int add(int i) {
if (d==0 && n1[i]!=0 && n2[i]!=0) {
int r= add(i+1);
if (d<0) {
n3[i+1] = addchar((i+d<0)?'0':n1[i+d],n2[i],r);
r = overflow((i+d<0)?'0':n1[i+d],n2[i],r);
}
if (d>0) {
n3[i+1] = addchar(n1[i],(i-d<0)?'0':n2[i-d],r);
r = overflow(n1[i],(i-d<0)?'0':n2[i-d],r);
}
if (d==0) {
n3[i+1] = addchar(n1[i],n2[i],r);
r = overflow(n1[i],n2[i],r);
}
if (i==0) {
n3[i] = r+'0';
r = 0;
}
return r;
}
if (d>=0 && n1[i]!=0) {
d++;
int r = add(i+1);
n3[i+1] = addchar(n1[i],(i-d<0)?'0':n2[i-d],r);
return overflow(n1[i],(i-d<0)?'0':n2[i-d],r);
}
if (d<=0 && n2[i]!=0) {
d--;
int r = add(i+1);
n3[i+1] = addchar((i+d<0)?'0':n1[i+d],n2[i],r);
return overflow((i+d<0)?'0':n1[i+d],n2[i],r);
}
n3[i+1] = '\0';
return 0;
}
int main() {
add(0);
printf("%s %s %s\n",n1,n2,n3);
}
The basic idea is to calculate the maximal length and the difference between lengths of numbers when descending through recursion, and then adding the right digits when returning from the recursion. The main difficulty is to manage the difference between the lengths.
This algorithm adds a leading zero to the result when there is no overflow on the left.

Answer 4

You could check for error in strings and do the sum at the same time,
#include <stdio.h>
#include <stdlib.h>
#define MAX_RES 1000
char *s1,*s2,*res;
int getcharval(char *s, int i) {
int n = s[i] - '0';
return n<0 || n>9 ? -1 : n;
}
char *recsum(int i1, int i2, int carry, char *pres) {
int n1 = !i1 ? 0 : getcharval(s1, --i1);
int n2 = !i2 ? 0 : getcharval(s2, --i2);
if (n1 < 0 || n2 < 0) return NULL;
int n = n1 + n2 + carry;
*--pres = (n % 10) + '0';
return !i1 && !i2 ? pres : recsum(i1, i2, n/10, pres);
}
with s1 points to string 1, s2 points to string 2, res points to the result area.
The recursive function recsum does the work, taking i1 decreasing index to next char in s1, i2 decreasing index to next char in s2, carry is the result from the previous calculation and pres (p-res) points to the next result char (+1) in res.
The helper function getcharval gets the digit from strings s index i, and returns that number (0 to 9) or -1 if the character is not a digit.
recsum returns a pointer to the result, i.e. a pointer into res where the result starts.
If there was an error in either string, the function returns NULL instead.
An example as how to use recsum, for a result having 1000 chars max (MAX_RES)
int main (int argc, char **argv)
{
s1 = "02313123";
s2 = "92382472699";
res = malloc(MAX_RES+1);
res[MAX_RES] = 0;
char *ret = recsum(strlen(s1), strlen(s2), 0, res+MAX_RES);
if (!ret) printf("There is an error\n");
else printf("%s + %s = %s\n", s1, s2, ret);
return 0;
}

Answer 5

Since If think this is homework, I only show pseudocode.
def str_sum(a,b):
index_a = len(a)
index_b = len(b)
res_len = max(len(a), len(b))
result = calloc(res_len+2, 1)
if not result:
raise OutOfMemory()
index_a -=1
index_b -= 1
acc = 0
res_index = 0
while (index_a >=0) or (index_b >= 0):
chr_a = '0'
chr_b = '0'
if(index_a >=0):
chr_a = a[index_a]
if(index_b >=0):
chr_b = b[index_b]
temp = acc + ord(chr_a) - ord('0') + ord(chr_b) - ord('0')
result[res_index] = chr((temp % 10) + ord('0'))
acc = temp / 10
index_a -=1
index_b -= 1
res_index += 1
inplace_rewind(result)
return ''.join(result)
print str_sum('9023905350290349', '90283056923840923840239480239480234')