Question

2 ^ 15 = 32768，其数字之和为3 + 2 + 7 + 6 + 8 = 26.

数字2次幂1000（2 ^ 1000）的数字总和是多少？

任何人都可以在java中为这个问题提供解决方案或算法吗？

Answer 1

这是我的解决方案：

public static void main(String[] args) {

    ArrayList<Integer> n = myPow(2, 100);

    int result = 0;
    for (Integer i : n) {
        result += i;
    }

    System.out.println(result);
}

public static ArrayList<Integer> myPow(int n, int p) {
    ArrayList<Integer> nl = new ArrayList<Integer>();
    for (char c : Integer.toString(n).toCharArray()) {
        nl.add(c - 48);
    }

    for (int i = 1; i < p; i++) {
        nl = mySum(nl, nl);
    }

    return nl;
}

public static ArrayList<Integer> mySum(ArrayList<Integer> n1, ArrayList<Integer> n2) {
    ArrayList<Integer> result = new ArrayList<Integer>();

    int carry = 0;

    int max = Math.max(n1.size(), n2.size());
    if (n1.size() != max)
        n1 = normalizeList(n1, max);
    if (n2.size() != max)
        n2 = normalizeList(n2, max);

    for (int i = max - 1; i >= 0; i--) {
        int n = n1.get(i) + n2.get(i) + carry;
        carry = 0;
        if (n > 9) {
            String s = Integer.toString(n);
            carry = s.charAt(0) - 48;
            result.add(0, s.charAt(s.length() - 1) - 48);
        } else
            result.add(0, n);
    }

    if (carry != 0)
        result.add(0, carry);

    return result;
}

public static ArrayList<Integer> normalizeList(ArrayList<Integer> l, int max) {
    int newSize = max - l.size();
    for (int i = 0; i < newSize; i++) {
        l.add(0, 0);
    }
    return l;
}

这段代码可以通过多种方式进行改进......只是为了证明你可以在没有BigInts的情况下完美地完成它。

捕捉是将每个数字转换为列表。这样你可以做基本的总和，如：

123456
+   45
______
123501

Answer 2

int result = 0;

String val = BigInteger.valueOf(2).pow(1000).toString();

for(char a : val.toCharArray()){
    result = result + Character.getNumericValue(a);
}
System.out.println("val ==>" + result);

如果你知道如何使用biginteger，这很简单。

Answer 3

我不会提供代码，但java.math.BigInteger应该使这一点变得微不足道。

Answer 4

创建长度为302的向量，长度为2 ^ 1000。然后，在索引0处保存2，然后加倍1000次。只要查看每个索引，如果之前的代码为10，则将1添加到下一个索引。然后将其总结一下！

Answer 5

这个问题不只是问你如何找到最近的大整数库，所以我会避免这个解决方案。 This page has a good overview这个特殊问题。

Answer 6

这样的事情可以做到这一点： - 虽然有一个很好的分析解决方案（想想笔和纸）使用数学 - 这也适用于大于1000的数字。

    final String bignumber = BigInteger.valueOf(2).pow(1000).toString(10);
    long result = 0;
    for (int i = 0; i < bignumber.length(); i++) {
        result += Integer.valueOf(String.valueOf(bignumber.charAt(i)));
    }
    System.out.println("result: " + result);

Answer 7

如何交替表达2 ^ 1000？

我在数学时代记不得太多，但也许像（2 ^（2 ^ 500））？怎么能表达出来呢？

找到一种简单的方法来计算2 ^ 1000，将结果放在BigInteger中，其余的可能是微不足道的。

Answer 8

这是我的代码......请提供运行此代码的必要参数。

import java.math.BigInteger;

public class Question1 {
    private static int SumOfDigits(BigInteger inputDigit) {
        int sum = 0;
        while(inputDigit.bitLength() > 0) {
            sum += inputDigit.remainder(new BigInteger("10")).intValue();
            inputDigit = inputDigit.divide(new BigInteger("10"));       
        }                       
        return sum;
    }

    public static void main(String[] args) {
        BigInteger baseNumber = new BigInteger(args[0]);
        int powerNumber = Integer.parseInt(args[1]);
        BigInteger powerResult = baseNumber.pow(powerNumber);
        System.out.println(baseNumber + "^" + powerNumber + " = " + powerResult);
        System.out.println("Sum of Digits = " + Question1.SumOfDigits(powerResult));
    }

}

Answer 9

2 ^ 1000是一个非常大的值，你必须使用BigIntegers。算法类似于：

import java.math.BigInteger;
BigInteger two = new BigInteger("2");
BigInteger value = two.pow(1000);
int sum = 0;
while (value > 0) {
  sum += value.remainder(new BigInteger("10"));
  value = value.divide(new BigInteger("10"));
}

Answer 10

或者，你可以获得一个双倍manipulate its bits。如果数字是2的幂，则不会出现截断错误。然后你可以将它转换为字符串。

话虽如此，它仍然是一种蛮力的方法。必须有一个很好的数学方法来实现它而不实际生成数字。

Answer 11

In[1162] := Plus @@ IntegerDigits[2^1000]
Out[1162] = 1366

数字的总和2 ^ 1000

11 个答案: