在C中递归地添加两个由数字组成的字符串

对于这个问题，我首先使用fgets接收两个字符串。然后我需要检查字符串是否完全由数字组成，从而使其成为数字。我可以递归地完成这部分，但下一个任务是，如果字符串是数字，我也需要递归地求和。那么比如说,， 程序的输出可能如下所示：

第一个号码>90239005350290349

第二个号码>90283056923840923840239480239480234

总数为90283056923840923849263385589770583

---

同样，我需要递归地完成这项工作，所以我想我可以沿着数字流前进并将它们相加，但我不太确定如何递归地编写这个程序。此外，由于输入是字符形式，我还必须将其转换为整数，我相信我可以通过将单个字符转换为整数ASCII值，然后从中减去48来实现。任何帮助都将不胜感激。谢谢

更新：下面的评论让我意识到我显然误解了这个问题。当然，我以前的解决方案不会像OP问题中的那样处理大量数据。我相应地更新了我的答案，采用“从右到左”的方法。唯一的问题是，结果字符串可以有一个前导零

#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));
}

---

既然我认为这是家庭作业，我只显示伪代码

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')

---

你在正确的轨道上。检查输入是否为数字的递归方法如下所示，对吗？请注意，您可以继续从一个字符中减去

'0'

，而不用费心自己将其转换为48

整数长度（字符*s，整数位置）{
int d；
如果（s[pos]='\0'）{
返回pos；
}
d=s[pos]-“0”；
如果（d<0 | | d>9）{
返回-1；
} 
返回编号长度（s，位置+1）；
}

如果输入无效，上述函数返回-1，否则返回数字的长度。我们可以在开始递归加法过程时使用输入数字的长度

递归应该从哪里开始？当我们添加一对数字时，可以方便地从最低有效数字开始

如果我们有一对指向数字的

char*

变量

a

和

b

，并且如果我们知道

a

包含

a\u长度

数字和

b

包含

b\u长度

数字，那么：

• a

  的最低有效位位于

  a_长度-1

• b

  的最低有效位位于

  b_长度-1

我们事先不知道结果会持续多久，所以让我们从位置0开始在

int*

数组中建立数字。这意味着我们将得到相反的结果数字，因此我们将从末尾开始打印，然后返回到0

计算的核心是：

• 给定

  a

  中的

  a\u pos

  和

  b\u pos

  中的

  b\u pos

  位置以及进位位数

  carry

  ，计算

  a

  和

  b

  中的位数和进位位数

• 更新进位数字

• 将结果数字添加到结果数组并更新数组的长度

在C中，我们可以将计算表示为：

d=a[a_pos--]+b[b_pos--]-2*'0'+进位；
进位=（d>=10？1:0）；
结果[result_pos++]=d%10；

一旦

a\u pos

或

b\u pos

变为负数，表达式

a[a\u pos--]+b[b\u pos--]

将无效。换句话说，我们必须处理一个数字或两个数字的数字都用完的情况。我们必须注意：

• 处理已处理

  a

  但未处理

  b

  或

  b

  但未处理

  a

  的最高有效位的情况

• 当我们到达

  a

  和

  b

  的末尾时，记得检查进位数字：如果是1，则将其添加到结果中并增加结果的长度

下面是ANSI C中的完整实现

#包括
#包括
#定义缓冲区大小8192
字符a[缓冲区大小]，b[缓冲区大小]；
int结果[缓冲区大小]；
整数长度（字符*s，整数位置）{
int d；
如果（s[pos]='\0'）{
返回pos；
}
d=s[pos]-“0”；
如果（d<0 | | d>9）{
返回-1；
} 
返回编号长度（s，位置+1）；
}
整数相加（字符a，字符a，字符b，字符b，
整数*结果，整数结果（位置，整数进位）{
int d；
如果（a位置<0和b位置<0）{
如果（进位==1）{
结果[result_pos++]=1；
}
返回结果位置；
}
如果（a_pos<0）{
结果[result_pos++]=b[b_pos--]-“0”+进位；
进位=0；
}否则如果（b_位置<0）{
结果[result_pos++]=a[a_pos--]-“0”+进位；
进位=0；
}否则{
d=a[a位置--]+b[b位置--]-2*'0'+进位；
进位=（d>=10？1:0）；
结果[result_pos++]=d%10；
}
返回添加（a、a位置、b、b位置、结果、结果位置、进位）；
}
int main（）{
int a_长度，b_长度，i，结果_长度；
printf（“第一个数字>”）；
scanf（“%s”，a）；
如果（（a_长度=数字_长度（a，0））=-1）{
printf（“%s不是一个数字。\n”，a）；
返回0；
}
printf（“第二个数字>”）；
scanf（“%s”，b）；
如果（（b_长度=数字_长度（b，0））=-1）{
printf（“%s不是一个数字。\n”，b）；
返回0；
}
结果长度=相加（a，a长度-1，b，b长度-1，结果，0，0）；
对于（i=result_length-1；i>=0；--i）{
printf（“%d”，结果[i]）；
}
printf（“\n”）；
返回0；
}

在一次递归下降中实现这一点并不容易，但这可以实现：

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);
}

charn1[]=“90239005350290349”；
字符n2[]=“90283056923840923840239480239480234”；
charn3[1000]；
char addchar（char c、char d、int r）{
返回（（c-'0'）+（d-'0'）+r）%10+'0'；
}
整数溢出（字符c、字符d、整数r）{
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);
}

#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);
}

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;
}