Unlucky number 13

Question

I came across this problem Unlucky number 13! recently but could not think of efficient solution this.

Problem statement :

N is taken as input.

Answer 1

This a P&C problem. I'm going to assume 0 is valid string and so is 00, 000 and so on, each being treated distinct from the other.

The total number of strings not containing 13, of length N, is unsurprisingly given by:

(Total Number of strings of length N) - (Total number of strings of length N that have 13 in them)

Now, the Total number of strings of length N is easy, you have 10 digits and N slots to put them in: 10^N.

The number of strings of length N with 13 in them is a little trickier. You'd think you can do something like this:

=> (N-1)C1 * 10^(N-2)
=> (N-1) * 10^(N-2)

But you'd be wrong, or more accurately, you'd be over counting certain strings. For example, you'd be over counting the set of string that have two or more 13s in them.

What you really need to do is apply the inclusion-exclusion principle to count the number of strings with 13 in them, so that they're all included once.

If you look at this problem as a set counting problem, you have quite a few sets:

S(0,N): Set of all strings of Length N.
S(1,N): Set of all strings of Length N, with at least one '13' in it.
S(2,N): Set of all strings of Length N, with at least two '13's in it.
...
S(N/2,N): Set of all strings of Length N, with at least floor(N/2) '13's in it.

You want the set of all strings with 13 in them, but counted at most once. You can use the inclusion-exclusion principle for computing that set.

Answer 2

In fact this question is more about math than about python. For N figures there is 10^N possible unique strings. To get the answer to the problem we need to subtract the number of string containing "13". If string starts from "13" we have 10^(N-2) possible unique strings. If we have 13 at the second possition (e.i. a string like x13...), we again have 10^(N-2) possibilities. But we can't continue this logic further as this will lead us to double calculation of string which have 13 at different possitions. For example for N=4 there will be a string "1313" which we will calculate twice. To avoid this we should calculate only those strings which we haven't calculated before. So for "13" on possition p (counting from 0) we should find the number of unique string which don't have "13" on the left side from p, that is for each p number_of_strings_for_13_at_p = total_number_of_strings_without_13(N=p-1) * 10^(N-p-2) So we recursevily define the total_number_of_strings_without_13 function.

Here is the idea in the code:

def number_of_strings_without_13(N):
    sum_numbers_with_13 = 0
    for p in range(N-1):
        if p < 2:
            sum_numbers_with_13 += 10**(N-2)
        else:
            sum_numbers_with_13 += number_of_strings_without_13(p) * 10**(N-p-2)

    return 10**N - sum_numbers_with_13

I should say that 10**N means 10 in the power of N. All the other is described above. The functions also has a surprisingly pleasent ability to give correct answers for N=1 and N=2.

To test this works correct I've rewritten your code into function and refactored a little bit:

def number_of_strings_without_13_bruteforce(N):
    without_13 = 0
    for i in range(10**N):
        if str(i).count("13"):
            continue
        without_13 += 1
    return without_13

for N in range(1, 7):
    print(number_of_strings_without_13(N),
          number_of_strings_without_13_bruteforce(N))

They gave the same answers. With bigger N bruteforce is very slow. But for very large N recursive function also gets mush slower. There is a well known solution for that: as we use the value of number_of_strings_without_13 with parameters smaller than N multiple times, we should remember the answers and not recalculate them each time. It's quite simple to do like this:

def number_of_strings_without_13(N, answers=dict()):
    if N in answers:
        return answers[N]

    sum_numbers_with_13 = 0
    for p in range(N-1):
        if p < 2:
            sum_numbers_with_13 += 10**(N-2)
        else:
            sum_numbers_with_13 += number_of_strings_without_13(p) * 10**(N-p-2)

    result = 10**N - sum_numbers_with_13
    answers[N] = result
    return result

Answer 3

Thanks to L3viathan's comment now it is clear. The logic is beautiful.

Let's assume a(n) is a number of strings of n digits without "13" in it. If we know all the good strings for n-1, we can add one more digit to the left of each string and calculate a(n). As we can combine previous digits with any of 10 new, we will get 10*a(n-1) different strings. But we must subtract the number of strings, which now starts with "13" which we wrongly summed like OK at the previous step. There is a(n-2) of such wrongly added strings. So a(n) = 10*a(n-1) - a(n-2). That is it. Such simple.

What is even more interesting is that this sequence can be calculated without iterations with a formula https://oeis.org/A004189 But practically that doesn't helps much, as the formula requires floating point calculations which will lead to rounding and would not work for big n (will give answer with some mistake).

Nevertheless the original sequence is quite easy to calculate and it doesn't need to store all the previous values, just the last two. So here is the code

def number_of_strings(n):
    result = 0
    result1 = 99
    result2 = 10
    if n == 1:
        return result2
    if n == 2:
        return result1
    for i in range(3, n+1):
        result = 10*result1 - result2
        result2 = result1
        result1 = result
    return result 

This one is several orders faster than my previous suggestion. And memory consumption is now just O(n)

P.S. If you run this with Python2, you'd better change range to xrange

Answer 4

I get the feeling that this question is designed with the expectation that you would initially instinctively do it the way you have. However, I believe there's a slightly different approach that would be faster.

You can produce all the numbers that contain the number 13 yourself, without having to loop through all the numbers in between. For example:

2 digits: 13

3 digits position 1: 113 213 313 etc.

3 digits position 2: 131 132 133 etc.

Therefore, you don't have to check all the number from 0 to n*9. You simply count all the numbers with 13 in them until the length is larger than N.

This may not be the fastest solution (in fact I'd be surprised if this couldn't be solved efficiently by using some mathematics trickery) but I believe it will be more efficient than the approach you have currently taken.

Answer 5

I think this can be solved via recursion:

ans(n) = { ans([n/2])^2 - ans([n/2]-1)^2 }, if n is even
ans(n) = { ans([n/2]+1)*ans([n/2]) - ans([n/2])*ans([n/2]-1) }, if n is odd

Base Cases:

• ans(0) = 1
• ans(1) = 10

It's implementation is running quite fast even for larger inputs like 10^9 ( which is expected as its complexity is O(log[n]) instead of O(n) like the other answers ):

cache = {}

mod = 1000000009

def ans(n):
    if cache.has_key(n):
        return cache[n]

    if n == 0:
        cache[n] = 1
        return cache[n]
    if n == 1:
        cache[n] = 10
        return cache[n]

    temp1 = ans(n/2)
    temp2 = ans(n/2-1)

    if (n & 1) == 0:
        cache[n] = (temp1*temp1 - temp2*temp2) % mod
    else:
        temp3 = ans(n/2 + 1)
        cache[n] = (temp1 * (temp3 - temp2)) % mod

    return cache[n]

print ans(1000000000)

Online Demo

Explanation:

Let a string s have even number of digits 'n'.
Let ans(n) be the answer for the input n, i.e. the number of strings without the substring 13 in them.
Therefore, the answer for string s having length n can be written as the multiplication of the answer for the first half of the string (ans([n/2])) and the answer for the second half of the string (ans([n/2])), minus the number of cases where the string 13 appears in the middle of the number n, i.e. when the last digit of the first half is 1 and the first digit of the second half is 3.

This can expressed mathematically as:

ans(n) = ans([n/2])^2 - ans([n/2]-1)*2

Similarly for the cases where the input number n is odd, we can derive the following equation:

ans(n) = ans([n/2]+1)*ans([n/2]) - ans([n/2])*ans([n/2]-1)

Answer 6

Let f(n) be the number of sequences of length n that have no "13" in them, and g(n) be the number of sequences of length n that have "13" in them.

Then f(n) = 10^n - g(n) (in mathematical notation), because it's the number of possible sequences (10^n) minus the ones that contain "13".

Base cases:

f(0) = 1
g(0) = 0
f(1) = 10
g(1) = 0

When looking for the sequences with "13", a sequence can have a "13" at the beginning. That will account for 10^(n-2) possible sequences with "13" in them. It could also have a "13" in the second position, again accounting for 10^(n-2) possible sequences. But if it has a "13" in the third position, and we'd assume there would also be 10^(n-2) possible sequences, we could those twice that already had a "13" in the first position. So we have to substract them. Instead, we count 10^(n-4) times f(2) (because those are exactly the combinations in the first two positions that don't have "13" in them).

E.g. for g(5):

g(5) = 10^(n-2) + 10^(n-2) + f(2)*10^(n-4) + f(3)*10^(n-5)

We can rewrite that to look the same everywhere:

g(5) = f(0)*10^(n-2) + f(1)*10^(n-3) + f(2)*10^(n-4) + f(3)*10^(n-5)

Or simply the sum of f(i)*10^(n-(i+2)) with i ranging from 0 to n-2.

In Python:

from functools import lru_cache

@lru_cache(maxsize=1024)
def f(n):
    return 10**n - g(n)

@lru_cache(maxsize=1024)
def g(n):
    return sum(f(i)*10**(n-(i+2)) for i in range(n-1))  # range is exclusive

The lru_cache is optional, but often a good idea when working with recursion.

---

>>> [f(n) for n in range(10)]
[1, 10, 99, 980, 9701, 96030, 950599, 9409960, 93149001, 922080050]

The results are instant and it works for very large numbers.