Integer 破解密码书平方根算法中的范围

Question

There is an algorithm in java for square root in cracking the code book as below:

int sqrt(int n) {
  return sqrt_helper(n, 1, n);
}

int sqrt_helper(int n, int min, int max) {
  if (max < min) return -1; 
  int guess = (min + max) / 2·,
  if (guess *guess == n) { 
    return guess;
  } else if (guess * guess < n) { 
    return sqrt_helper(n, guess + 1, max); 
  } else {  
    return sqrt_helper(n, min, guess - l); 
  }
}

The question is:

As min and max are integer, they can have any values in the range, ie max = Integer.MAX_VALUE

So how not be worry about guess = (min + max) / 2 as it will cross the allowed range, or guess *guess also.

Answer 1

Since you mention "Cracking the Coding Interview"...

Typically in the context of the average coding interview one wouldn't worry about implementation-specific details like this. The interviewer is trying to confirm basic competency and understanding - they'll rarely want to run your code, and it should be a given for both of you that the algorithm will break down at the extreme limits of your language's basic data types. If the interviewer asks specifically about limitations, then you could briefly mention that the function will fail for values higher than (Integer.MAX_VALUE / 2) in this language.

The limitation will apply to almost any algorithm you write for a coding interview, and no reasonable interviewer would expect you to specifically design your solution to mitigate this kind of edge case. I would find it extremely off-putting if I asked a candidate to write a function that produces Fibonacci numbers and they spent time trying to optimize the case where the output exceeds 16 digit values.

If for some reason you needed to find the square root of extremely large values using this algorithm in a real life scenario, I'd expect you'd to have to implement it using a generic big number library for your particular language. That being said, I wouldn't roll my own square root algorithm for any real use case under almost any circumstance.

Answer 2

There are simple ways of getting around that problem (like min + (max - min) / 2 ).

The more serious integer overflow problem is guess * guess . You could change the test to compare guess with n / guess , which is slower but normally won't overflow. Or you could use a bit hack to find a better starting point ( clz is useful here, if you have it), since you should be able to find a guess whose square is within the range of representable integers.

An interviewer might be even more impressed if you were able to provide the Newton-Raphson algorithm , which converges extremely rapidly.

Answer 3

You'd have to confirm your language. But in pseudo-code you can do something like:

int guess = ((min.ToBigInt() + max.ToBigInt()) / 2).ToInt()