表示已知大小变量的表达式结果的最小位数？

Question

I'm trying to learn more about how computers store memory. So I've found information on how to represent binary numbers or hexadecimal numbers, but I found a question asking:

Given three n-bit unsigned ints: x, y, z, what is the min # 
of bits required to represent x * y + z 

So my thinking is: Do I have to just account for all three ints separately and do the math for the smallest possible numbers so for example 0 * 0 + 0

Or do I have to account for another variable n that is the result of the problem?

I'm having some trouble thinking this out.

Answer 1

The number of bits required is n + n . Taking an example using 8 bits and maximum unsigned values:

255 * 255 + 255 = 65280

The result is less then 65536 which would require more than 16 bits.

Answer 2

Max value of an n-bit unsigned number is 2 ⁿ - 1.

The max result of

a*b + c

would be:

(2 ⁿ - 1)*(2 ⁿ - 1) + (2 ⁿ - 1)

(2 ²ⁿ - 2 ⁿ - 2 ⁿ + 1) + (2 ⁿ - 1)

2 ²ⁿ - 2 ⁿ

Therefore, since

2 ²ⁿ - 2 ⁿ

is less than the maximum (2*n)-bit unsigned number: 2 ²ⁿ - 1, (2*n) bits will suffice to represent any answer.

Examples of how to code it

uint64_t ab_plus_c_bad(uint32_t a, uint32_t b, uint32_t c) {
  return a*b + c;  // potential overflow with product.
}

uint64_t ab_plus_c_good(uint32_t a, uint32_t b, uint32_t c) {
  // a is widened before the multiplication
  return (uint64_t) a*b + c;  // no product overflow
}

Answer 3

The maximum value that can be represented is pow(2,n)-1. and your equation yields (pow(2,n)-1) * (pow(2,n)-1) + (pow(2,n)-1)

So to find out how many bits are required

n |max val.| max eqn.   | req'd bits 
--|--------|------------|-----------
1 |   1    |  1*1+1=2   | 2
2 |   3    |  3*3+3=12  | 4
3 |   7    |  7*7+7=56  | 6
4 |   15   |15*15+15=240| 8
5 |   31   |31*31+31=992| 10
...see the pattern

To figure this out for any n, use something like this:

//This uses double since the loss of precision will be insignificant
//but covers a large range of n.
//There are more efficient ways for small values of n.
//long double could be used instead for REALLY large values of n
#include <math.h>
#define n 999UL

//the highest unsigned value that can be represented by n bits is:
double max_value = pow(2.0, (double)n) - 1.0;

//figure out the max value you can get with your equation
double max_eqn = max_value * max_value + max_value;

//take the log base 2 of that and round it up to get max bits
//note that log base x of n is equal to log(n)/log(x);
unsigned long req_bits = (unsigned long) ceil(log(max_eqn)/log(2.0));

printf("The maximum required number of bits for %ul bits is %ul", n, req_bits);