Scala algorithm: Count binary gap size of a number using tail recursion

Algorithm to find the maximum length of a gap between a pair of 1s in a binary representation of a digit. This problem is also known as:true

Algorithm goal

Algorithm to find the maximum length of a gap between a pair of 1s in a binary representation of a digit. This problem is also known as:

  • On Codility: Find longest sequence of zeros in binary representation of an integer.
  • On HackerRank: Balanced Brackets - Given strings of brackets, determine whether each sequence of brackets is balanced. If a string is balanced, return YES. Otherwise, return NO.


Tail recursion allows us to perform iteration without having to mutate variables. While Scala permits mutation, immutability allows for more possibilities, such as being able to adopt an algorithm to run in a streamed way.

We have to consider 5 cases of an input number in this algorithm: (this is © from

  1. Pure zeroes: 0b000000, which have no gaps
  2. Numbers like 0b0000100, which also has no gaps
  3. Numbers like 0b0001100, which has no gaps
  4. Numbers like 0b001001 and 0b00100100, which have a gap
  5. Numbers like 0b01000101, which have 2 gaps, resuting in max gap of 3

Bit-wise operations will come to our help: for example 0b110 & 0b010 == 0b010, and bit shifting 0b110 >> 1 == 0b011. Upon familiarising with these, we can iterate through a number by bit-shifting it and comparing the last digit - to basically iterate through the binary digits of a number.

Initially, we ignore any first sequence of zeroes; when we reach a 1, we begin counting; if the next digit is a 1, we re-set the counter and include the length of the counter to a stack (or in Scala, a List); if the next digit is a 0, we increment the counter; and we repeat until we have shifted the number to be 0.

Scala concepts & Hints

  1. Def Inside Def

    A great aspect of Scala is being able to declare functions inside functions, making it possible to reduce repetition.

    def exampleDef(input: String): String = {
      def surroundInputWith(char: Char): String = s"$char$input$char"
    assert(exampleDef("test") == "-test-")

    It is also frequently used in combination with Tail Recursion.

  2. Option Type

    The 'Option' type is used to describe a computation that either has a result or does not. In Scala, you can 'chain' Option processing, combine with lists and other data structures. For example, you can also turn a pattern-match into a function that return an Option, and vice-versa!

    assert(Option(1).flatMap(x => Option(x + 2)) == Option(3))
    assert(Option(1).flatMap(x => None) == None)
  3. Stack Safety

    Stack safety is present where a function cannot crash due to overflowing the limit of number of recursive calls.

    This function will work for n = 5, but will not work for n = 2000 (crash with java.lang.StackOverflowError) - however there is a way to fix it :-)

    In Scala Algorithms, we try to write the algorithms in a stack-safe way, where possible, so that when you use the algorithms, they will not crash on large inputs. However, stack-safe implementations are often more complex, and in some cases, overly complex, for the task at hand.

    def sum(from: Int, until: Int): Int =
      if (from == until) until else from + sum(from + 1, until)
    def thisWillSucceed: Int = sum(1, 5)
    def thisWillFail: Int = sum(1, 300)
  4. Tail Recursion

    In Scala, tail recursion enables you to rewrite a mutable structure such as a while-loop, into an immutable algorithm.

    def fibonacci(n: Int): Int = {
      def go(i: Int, previous: Int, beforePrevious: Int): Int =
        if (i >= n) previous else go(i + 1, previous + beforePrevious, previous)
      go(i = 1, previous = 1, beforePrevious = 0)
    assert(fibonacci(8) == 21)

Algorithm in Scala

29 lines of Scala (version 2.13), showing how concise Scala can be!

def removeRightZeroes(number: Int): Int = {
  if (number == 0) number
  else if (isOdd(number)) number
  else removeRightZeroes(number >> 1)

def isEven(n: Int): Boolean = !isOdd(n)

def isOdd(n: Int): Boolean = (n & 1) == 1

def maximumBinaryGap(n: Int): Option[Int] = {
  if (n <= 0) None
  else {
    val numberStartingWith1 = removeRightZeroes(n)
    def iterate(
        currentNumber: Int,
        currentCount: Int,
        gapCounts: List[Int]
    ): Option[Int] =
      if (currentNumber == 1)
        (currentCount :: gapCounts).maxOption.filter(_ > 0)
      else if (isEven(currentNumber))
        iterate(currentNumber >> 1, currentCount + 1, gapCounts)
      else iterate(currentNumber >> 1, 0, currentCount :: gapCounts)
    iterate(numberStartingWith1, 0, Nil)

Test cases in Scala

  removeRightZeroes(12) == 3,
  "12, with zeroes on the right removed, is 3, because it's 8 + 4 = 0b1100, becoming 0b11 which is 3"
  "76215 has a gap of 4, because it's represented as 0b1100001001001"
  "16 has no gaps at all because it's represented as 0b10000"
  "1 has no gap either because it's represented as 0b0000001"

View the rest of Scala algorithms