Question

Given a binary digit count of n, and a maximum consecutive occurrence count of m, find the number of different possible binary numbers. Also, the leftmost and rightmost bit must be 1.

For example n = 5, and m = 3.

The count is 7:
10001
10011
10101
10111
11001
11011
11101

Notice we excluded 11111 because too many consecutive 1’s exist in it.

This was an interview question I had recently, and It has been bothering me. I don’t want to brute force check each number for legitimacy because n can be > 32.

Answer 1

Let’s call a binary sequence almost valid if it starts with “1” and has at most m consecutive “1” digits.

For i = 1, ..., n and j = 0, ..., m let a(i, j) be the number of almost valid sequences with length i that end with exactly j consecutive “1” digits.

Then

• a(1, 1) = 1 and a(1, j) = 0 for j != 1, because “1” is the only almost valid sequence of length one.
• For n >= 2 and j = 0 we have a(i, 0) = a(i-1, 0) + a(i-1, 1) + ... + a(i-1, m), because appending “0” to any almost valid sequence of length i-1 gives an almost valid sequence of length i ending with “0”.
• For n >= 2 and j > 0 we have a(i, j) = a(i-1, j-1) because appending “1” to an almost valid sequence with i-1 trailing ones gives an almost valid sequence of length j with i trailing ones.

Finally, the wanted number is the number of almost valid sequences with length n that have a trailing “1”, so this is

f(n, m) = a(n, 1) + a(n, 2) + ... + a(n, m)

Written as a C function:

int a[NMAX+1][MMAX+1];
int f(int n, int m)
{
    int i, j, s;

    // compute a(1, j):
    for (j = 0; j <= m; j++)
        a[1][j] = (j == 1);

    for (i = 2; i <= n; i++) {
        // compute a(i, 0):
        s = 0;
        for (j = 0; j <= m; j++)
            s += a[i-1][j];
        a[i][0] = s;

        // compute a(i, j):
        for (j = 1; j <= m; j++)
            a[i][j] = a[i-1][j-1];
    }

    // final result:
    s = 0;
    for (j = 1; j <= m; j++)
        s += a[n][j];
    return s;
}

The storage requirement could even be improved, because only the last column of the matrix a is needed. The runtime complexity is O(n*m).