将数字序列的总和及其总和相加的递归函数

Question

这是一个面试问题：

给定一个由 n 个数字组成的序列（n 可以是任何数字，假设这个问题的 n 问题是在 C 中编写一个递归函数，将序列中的每个数字相加得到总和。如果该总和超过一位，则一次又一次地对数字求和，如果总和超过一位，则再次对数字求和。遵循此过程，直到总和减少到一位数。现在将过程中得到的所有总和相加，输出最终总和。

以上面的顺序为例：11、23、9、17、20、8、5、6

SUM(11, 23, 9, 17, 20, 8, 5, 6) = 99 => SUM(9, 9) = 18 => SUM(1, 8) = 9

现在将获得的所有总和相加，即SUM(99, 18, 9) = 126

请注意，该函数应该是C语言中的递归函数。

Answer 1

#include <iostream>
using namespace std;

class RecursiveSum {
public:
    int nDigits(int a) {
        int d = 0;
        while (a > 0) {
            d++;
            a /= 10;
        }
        return d;
    }

    long sum(int *arr, int b, int e, int s) {
        if (!arr)
            return 0;
        if (b < e) {
            s += arr[b++];
            return sum(arr, b, e, s);
        } else { // b >= e
            if (s < 10)
                return s;

            int nd = nDigits(s);
            int* narr = new int[nd];
            long n = s, itr = 0;
            while (n > 0) {
                narr[itr++] = n % 10;
                n /= 10;
            }

            s += sum(narr, 0, nd, 0);
            delete[] narr;

            return s;
        }
    }

};

Answer 2

我只想将这个添加到77v's answer，以使所有内容都尽可能地递归。我知道这是一年前的事了，他的 C++ 解决方案已经很好用了。但是我真的没有乐趣，尽管我可以将最后一个名为 sumDigits 的函数用于递归。所以为了摆脱无聊，这里是：

long sumDigits(long x, long d = 0)
{
    if (x != 0)
    {
        d = x % 10;
        return d + sumDigits(x / 10, d);
    }
    else
        return 0;
}

同样，7 行，接受一个参数。请注意，第二个默认为 0。它用作递归本身的内存。用户可以完全忽略第二个参数。该函数的使用方式也与 77v 的实现方式相同。您实际上可以直接用这个替换他的功能。因此使他的解决方案中的所有功能都基于递归。这让已经很棒的作品变得更棒了！哈哈！ :D

Answer 3

正如其他人所说：这里的重点是理解递归。

我们可以在三个地方使用递归：

• 将整数中的所有数字相加：

  sum_digital :: (Integral a) => a -> a
  sum_digital d
     | d < 10     = d
     | otherwise  = d `mod` 10 + sum_digital (d `div` 10)
  

• 从起始值和规则链接所有总和

  chain :: (Integral a) => a -> [a]
  chain a 
      | a < 10 = [a]
      | otherwise = a : chain (sum_digital a)
  

• 最后一个。列表的总和

  mySum :: (Integral a) => [a]-> a
  mySum [] = 0
  mySum (x:xs) = x + mySum xs 
  

把所有这些放在一起：

*Main> mySum $ chain $ mySum [11, 23, 9, 17, 20, 8, 5, 6]    
126

C 版本留给你作为练习:)

Answer 4

这是一个 Scala 实现：

def sum(lst: List[Int]): Int = { val sum1 = lst.reduceLeft(_+_) println(sum1) sum1 匹配 { 案例 nb 如果 nb sum1 案例_ => { val lst2 = sum1.toString.toList.map(_.toString).map(Integer.parseInt(_)) sum1 + sum(lst2) } } } val lst = List(11, 23, 9, 17, 20, 8, 5, 6) val totalSum = sum(lst) println(总和)

结果：

99 18 9 126

我真的开始爱上 Scala 的简洁了。

Answer 5

#include "stdafx.h"

#include <stdio.h>

#include <stdlib.h>

const int n = 8;

int sumDigits(int x)
{
    int d = 0;

    while (x != 0)
    {
        d += x % 10;
        x /= 10;
    }

    return d;
}

int sumArr(int* a, int start)
{
    return (start == n)? 0: a[start] + sumArr(a, start + 1);
}

int sum(int x)
{
    return (x < 10)? x: x + sum(sumDigits(x));
}

int main(int argc, _TCHAR* argv[])
{
    int* a = new int[n];
    a[0] = 11; a[1] = 23; a[2] = 9; a[3] = 17; a[4] = 20; a[5] = 8; a[6] = 5; a[7] = 6;
    //for (int i = 0; i < n; i++) a[i] = rand() % 100;
    //for (int i = 0; i < n; i++) printf("a[%d] = %d\n", i, a[i]);

    printf("sum = %d\n", sum(sumArr(a, 0)));

    return 0;
}

这输出： 总和 = 126

Answer 6

这是一个您可以用作指南的 Erlang 实现

-module('summation').  
-export([start/1]).  

sumlist(List)->
  lists:foldl(fun(X, Sum) -> X + Sum end, 0, List). << Inherently recursive

num_to_list(Value) ->
  Str = integer_to_list(Value),
  lists:map(fun(X) -> X - 48 end, Str).  << Inherently recursive

accumulate([_H], List) ->
  io:fwrite("~w~n", [List]),
  List;
accumulate(Value, List) ->
  Tmp = sumlist(Value),
  accumulate(num_to_list(Tmp), [Tmp|List]).  % << Recurse here

start(List)->
  Value = accumulate(List, []),
  sumlist(Value).

测试

25> c(summation).
{ok,summation}
26> summation:start([11, 23, 9, 17, 20, 8, 5, 6]).
[9,18,99]
126
27>

Answer 7

不确定 C，但算法看起来与此类似。

SUM(1, 2, ... n) = 1 + SUM(2, ... n) 以此类推得到总数，一旦发现最终数字超过一位，则重复。