Count the number of consecutive zeros in a number WITHOUT using loops - algorithm

Question

I found this to be asked as an interview question. While it is fairly trivial to solve using bit masking and loops, any idea on how this can be done without loops? While I'm looking for an algorithm, any code would be appreciated as well.

Answer 1

The options I see for solving the problem without loops are bit hacks, recursion and loop unrolling.
Solving this with bit hacks seems quite difficult - most likely something only the most skilled bit hackers would be able to figure out in the time limit of an interview, or really figure out at all, but it's possible that that's who they were looking for.
Loop unrolling is just a silly solution.
So that leaves recursion.
Below is a recursive solution in Java.
It basically maintains the current count of consecutive zeros and also the best count, checks the last digit (i.e. checks the number modulo 10), sets these values appropriately and recurses on the number without the last digit (i.e. divided by 10).
I assumed we're talking about zeros in the decimal representation of the number, but converting this to use the binary representation is trivial (just change 10 to 2).
public static int countMaxConsecutiveZeros(int number)
{
return countMaxConsecutiveZeros(number, 0, 0);
}
private static int countMaxConsecutiveZeros(int number, int currentCount, int bestCount)
{
if (number == 0)
return bestCount;
if (number % 10 == 0)
currentCount++;
else
{
bestCount = Math.max(bestCount, currentCount);
currentCount = 0;
}
return countMaxConsecutiveZeros(number / 10, currentCount, bestCount);
}
public static void main(String[] args)
{
System.out.println(countMaxConsecutiveZeros(40040001)); // prints 3
}
Here's a roughly equivalent loop-based solution, which should provide a better understanding of the recursive solution:
private static int countMaxConsecutiveZerosWithLoop(int number)
{
int currentCount = 0, bestCount = 0;
while (number > 0)
{
if (number % 10 == 0)
currentCount++;
else
{
bestCount = Math.max(bestCount, currentCount);
currentCount = 0;
}
number /= 10;
}
return bestCount;
}

Answer 2

I don't know if this is what they were looking for, but here is a recursive solution.
I used two recursions, one comparing the current string of zeros to the record, and another recursion calculating the current string of zeros.
public class countconsecutivezeros{
public static void main(String[] Args){
int number = 40040001; // whatever the number is
System.out.println(consecutivezeros(number, 0));
}
public static int consecutivezeros(int number, int max){
if (number != 0){
if (max < zerosfrompoint(number)) max = zerosfrompoint(number);
return consecutivezeros(number/10, max);
}
return max;
}
public static int zerosfrompoint(int number){
int zeros = 0;
if ((number != 0) && ((number/10)*10 == number)){
zeros++;
System.out.println(zeros);
return zeros + zerosfrompoint(number/10);
}
return zeros;
}
}