Optimizing Brute Force process in python / pypy for finding One-Child numbers

Question

This is my fastest brute force code. It use cython to speedup the calculation. Instead of check all the numbers, it finds all the One-Child numbers by recursion.

%%cython
cdef int _one_child_number(int s, int child_count, int digits_count):
    cdef int start, count, c, child_count2, s2, part, i
    if s >= 10**(digits_count-1):
        return child_count
    else:
        if s == 0:
            start = 1
        else:
            start = 0
        count = 0
        for c in range(start, 10):
            s2 = s*10 + c
            child_count2 = child_count
            i = 10
            while True:
                part = s2 % i
                if part % digits_count == 0:
                    child_count2 += 1
                    if child_count2 > 1:
                        break
                if part == s2:
                    break
                i *= 10

            if child_count2 <= 1:
                count += _one_child_number(s2, child_count2, digits_count)
        return count 

def one_child_number(int digits_count):
    return _one_child_number(0, 0, digits_count)

To find the number of F(10**7), it takes about 100ms to get the result 277674.

print sum(one_child_number(i) for i in xrange(8))

You need 64bit integer to calculate large results.

EDIT: I added some comment, but my English is not good, so I convert the code to pure python code, and add some print to help you figure out how it works.

The _one_child_number adds digit from left to s recursively, child_count is the child count in s, digits_count is the final digits of s.

def _one_child_number(s, child_count, digits_count):
    print s, child_count
    if s >= 10**(digits_count-1): # if the length of s is digits_count
        return child_count # child_count is 0 or 1 here, 1 means we found one one-child-number.
    else:
        if s == 0: 
            start = 1 #if the length of s is 0, we choose from 123456789 for the most left digit.
        else:
            start = 0 #otherwise we choose from 0123456789 
        count = 0 # init the one-child-number count
        for c in range(start, 10): # loop for every digit
            s2 = s*10 + c  # add digit c to the right of s

            # following code calculates the child count of s2
            child_count2 = child_count 
            i = 10
            while True:
                part = s2 % i
                if part % digits_count == 0:
                    child_count2 += 1
                    if child_count2 > 1: # when child count > 1, it's not a one-child-number, break
                        break
                if part == s2:
                    break
                i *= 10

            # if the child count by far is less than or equal 1, 
            # call _one_child_number recursively to add next digit.
            if child_count2 <= 1: 
                count += _one_child_number(s2, child_count2, digits_count)
        return count

Here is he ouput of _one_child_number(0, 0, 3), and the count of one-child-number of 3 digits is the sum of the second column that the first column is a 3 digits number.