在 C 中计算 2^n 的数字和

Question

I am new to C and trying to write a program that calculates the sum of the digits of 2^n, where n<10^8.

For example, for 2^10, we'd have 1+0+2+4, which is 7.

Here's what I came up with:

#include <stdio.h>
#include <math.h>

int main()
{
   int n, t, sum = 0, remainder;

   printf("Enter an integer\n");
   scanf("%d", &n);

   t = pow(2, n);

   while (t != 0)
   {
      remainder = t % 10;
      sum       = sum + remainder;
      t         = t / 10;
   }

   printf("Sum of digits of 2 to the power of %d = %d\n", n, sum);

   return 0;
}

The problem is: the program works fine with numbers smaller than 30. Once I set n to a number higher than 30, the result is always -47 .

I really do not understand this error and what causes it.

Answer 1

An interesting problem to be sure, but I think the solution is way outside the scope of a simple answer if you wish to support large values of n , such as the 10 ⁸ you mentioned. The number 2 ^{10 8} requires 10 ⁸ + 1 (100,000,001) bits, or around 12 megabytes of memory, to store in binary . In decimal it has around 30 million digits.

Your int is 32 bits wide, which is why the signed int can't store 2 ³¹ – the 32nd bit is the sign while 2 ³¹ has a 1 followed by 31 zeros in binary, requiring 32 bits without the sign. So it overflows and is interpreted as a negative number. (Technically signed integer overflow is undefined behaviour in C.)

You can switch to an unsigned int to get rid of the sign and the undefined behaviour, in which case your new highest supported n will be 31. You almost certainly have 64-bit integers available, and perhaps even 128-bit, but 2 ¹²⁷ is still way less than 2 ^100000000 .

So either you need to find an algorithm to compute the decimal digits of a power of 2 without actually storing them (and only store the sum), or forget about trying to use any scalar types in standard C and get (or implement) an arbitrary precision math library operating on arrays (of bits, decimal digits, or binary-coded decimal digits). Alternatively, you can limit your solution to, say, uint64_t , but then you have n < 64, which is not nearly as interesting… =)

Answer 2

TL;TD

sum=(int)(log10(2)*n)+1;

or

double log10Of2=log10(2);

at the beginning and

sum=(int)(log10Of2*n);

when you want to calculate it.

Advantages

• It will not overflow until n overflows
• It is fast (just a multiplication)
• It is not much code

long answer

You produce an overflow because the numbers are too big. Because of that, they go into the negative section.

The amount of digits a number has equals the logarithm of the number(decimal=10) to the base of the numeric system you use without the decimal digits(casting to an int).

This would be

int(lg(2^n))

Because

lg(x)=lb(x)/lb(10)

you can change it to

int(lb(2^n)/lb(10))

lb and 2^ cancel out, so you just have

int(n/lb(10))

Let's get to the implementation:

lb(x) is the same as lg(x)/lg(2)

So, you have

int(n/lg(10)/lg(2))

lg(10) is 1 and if you dive something that is 1/something , it cancels out, so you have:

int(lg(2)*n)

In c, that is

(int)(log10(2)*n)

This would start counting with 0, so you would have to add one if you just want to get the number:

(int)(log10(2)*n)+1

What is log , lg , lb ... ?

log means logarithm. It is the opposite operation of power.

log(n,x) = n^x

while log(n,x) can be written as log _n (x).

log _n (x) can be changed to log _a (x)/log _a (n) which makes it easier to calculate in some cases.

lg(x) (decimal logarithm) is a short form of log ₁₀ (x).

lb(x) (binary logarithm) is a short form of log ₂ (x).

Disclaimer

If I mady any mistakes, please point it out in the comments.

Answer 3

For signed int t = pow(2,n) , if n >= 31 then t > INT_MAX .

You can use unsigned long long t = pow(2,n) instead.

This will allow you to go as up as n == 63 .

Also, since you're using base 2 , you can use (unsigned long long)1 << n instead of pow(2,n) .