计算给定数字中连续幂的数字总和

Question

在方法中计算数字总和与连续幂的最佳方法是什么？

例子：

calculateSum(5) -> returns 5^1 = 5
12 -> 1^1 + 2^2 = 5
26 -> 2^1 + 6^2 = 38
122 -> 1^1 + 2^2 + 2^3 = 13

我想使用流，因为我正在尝试练习一些 J8 功能，但找不到让它工作的方法。

编辑：我需要它来解决这个 kata：https://www.codewars.com/kata/5626b561280a42ecc50000d1/train/java

EDIT2：到目前为止，这是我的代码：

public static void calculateSum(int input) {
    String[] number = String.valueOf(input).split("");
    Map<Integer, Integer> map = Arrays.stream(number)
            .map(Integer::valueOf)
            .map(d -> (int) Math.pow(d, list.indexOf(d)))
            .collect(Collectors.toMap(d));
}

我不知道如何将来自number array 的数字与它们的连续幂进行映射，这样我就可以对那个映射中的值求和。

Answer 1

这是一个没有流的解决方案。

public static int digitPow(int n) {
    int result = 0;
    int count = (int)(Math.log10(n) + 1); // number of digits in n

    while (count > 0) {
        result += Math.pow((n % 10), count);
        n /= 10;
        count--;
    }

    return result;
}

Answer 2

这应该适合你：

```

String str = String.valueOf(122);
DoubleSummaryStatistics collect = IntStream.range(0, str.length()) //1
    .mapToObj(i -> {
        int digit = Character.digit(str.charAt(i), 10); //2
        return Math.pow(digit, i + 1); //3
    })
    .collect(Collectors.summarizingDouble(i -> i)); //4

System.out.println(collect.getSum());

```

1. 生成功率值
2. 从给定位置的字符中提取数字
3. 计算提取数的幂
4. 总结一切

Answer 3

要修复您已有的问题，诀窍是使用IntStream

public static void calculateSum(int input) {
    String[] number = String.valueOf(input).split("");
    int sum = IntStream.range(0, number.length)
        .map(i -> (int)Math.pow(Integer.valueOf(number[i]), i + 1))
        .sum();

    System.out.println(sum)
}

Answer 4

仅供参考： Stream 不是解决此类问题的好方法。强制使用 Streams 是不好的编码。编写好的代码的一部分，是识别工作的正确工具，而 Stream 不是这里使用的工具。

为了防止double 不准确的任何潜在问题，这里是一个纯int 解决方案：

private static int calculateSum(int input) {
    if (input < 0)
        throw new IllegalArgumentException("Negative: " + input);
    int[] digit = new int[10], power = new int[10];
    for (int i = 0, n = input; n != 0; i++, n /= 10) {
        for (int j = 0; j < i; j++)
            power[j] *= digit[j];
        power[i] = digit[i] = n % 10;
    }
    int sum = 0;
    for (int i = 0; i < 10; i++)
        sum += power[i];
    if (sum < 0)
        throw new ArithmeticException("Overflow: " + input);
    return sum;
}

测试

public static void main(String[] args) {
    test(5);
    test(12);
    test(26);
    test(122);
    test(Integer.MAX_VALUE);
    test(1999999998);
}
private static void test(int input) {
    System.out.printf("%d -> %d%n", input, calculateSum(input));
}

输出

5 -> 5
12 -> 5
26 -> 38
122 -> 13
2147483647 -> 284684832
1999999998 -> 1509589865

请注意，以9 结尾的 10 位数字会溢出。