I found an interesting problem on https://www.codewars.com/kata/5b713d7187c59b53e60000b0:
If we multiply the integer      `717 (n)` by `7 (k)`, the result will be equal to `5019`.

Consider all the possible ways that this last number may be split as a string and calculate their corresponding sum obtained by adding the substrings as integers. When we add all of them up,... surprise, we got the original number `717`:

```
Partitions as string                Total Sums
['5', '019']                        5 + 19 = 24
['50', '19']                       50 + 19 = 69
['501', '9']                      501 + 9 = 510
['5', '0', '19']                5 + 0 + 19 = 24
['5', '01', '9']                 5 + 1 + 9 = 15
['50', '1', '9']                50 + 1 + 9 = 60
['5', '0', '1', '9']         5 + 0 + 1 + 9 = 15
                            ____________________
                              Big Total:    717
                            ____________________
```
In fact, `717` is one of the few integers that has such property with a factor `k = 7`.

Changing the factor `k`, for example to `k = 3`, we may see that the integer `40104` fulfills this property.

Given an integer `start_value` and an integer `k`, output the smallest integer `n`, but higher than `start_value`, that fulfills the above explained properties.

If by chance, `start_value`, fulfills the property, do not return `start_value` as a result, only the next integer. Perhaps you may find this assertion redundant if you understood well the requirement of the kata: "output the smallest integer `n`, but higher than `start_value`"

The values for `k` in the input may be one of these: `3, 4, 5, 7`

### Features of the random tests

If you want to understand the style and features of the random tests, see the *Notes* at the end of these instructions.

The random tests are classified in three parts.

- Random tests each with one of the possible values of `k` and a random `start_value` in the interval `[100, 1300]`
- Random tests each with a `start_value` in a larger interval for each value of `k`, as follows:
 - for `k = 3`, a random `start value` in the range...

I tried it in Python, but could not do it. Can you solve it?
def partitions(s):
    if s:
        for i in range(1, len(s)+1):
            for p in partitions(s[i:]):
                yield [s[:i]] + p
    else:
        yield []
def add_values (product_string): 
  product_list = partitions(product_string)
  return sum([sum (map(int,items)) for items in list(product_list)[:-1]])
  
def next_higher(start_value,k):
    product = (start_value+1) * k
    while add_values(str(product)) != start_value:
        start_value+=1
        product = start_value*k
    return start_value