Sum of the digits of the number 2^1000 [closed]

Answer 1

I won't provide code, but java.math.BigInteger should make this trivial.

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

It's pretty simple if you know how to use the biginteger.

Answer 3

Here is my code... Please provide the necessary arguments to run this code.

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 4

Here is my solution:

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

This code can be improved in many ways ... it was just to prove you can perfectly do it without BigInts.

The catch is to transform each number to a list. That way you can do basic sums like:

123456
+   45
______
123501

Answer 5

Alternatively, you could grab a double and manipulate its bits. With numbers that are the power of 2, you won't have truncation errors. Then you can convert it to string.

Having that said, it's still a brute-force approach. There must be a nice, mathematical way to make it without actually generating a number.