Count of N digit numbers with sum of every K consecutive digits equal

This problem involves finding the count of N digit numbers where the sum of every K consecutive digits in the number is the same. For example, if K=3 and the sum of first three digits is 6, then the sum of second, third and fourth digit must also be 6 for a valid number.

Approach

We can start by generating all possible N digit numbers and then checking if the sum of every K consecutive digits is equal. However, this would be a very inefficient approach as the number of N digit numbers can be very large.

Instead, we can use a dynamic programming approach where we calculate the number of valid N digit numbers for each possible prefix. Let's say we have calculated the number of valid N digit numbers for prefixes of length l. To calculate the number of valid N digit numbers for prefixes of length l+1, we simply consider all valid prefixes of length l and append one more digit to them. The new digit appended can be any number between 0 to 9, but we can prune some of the possible digits by maintaining a running sum for every K consecutive digits.

For example, let's say K=3 and we have a prefix 1258 with a running sum of 6 for the first three digits. The valid digits that can be appended at the end are those whose sum with the previous two digits is equal to 6. These digits are {0, 1, 2, 3, 6}.

Using this approach, we can calculate the number of valid N digit numbers for a given N and K.

Code

def count_numbers(N, K):
    # Initialize DP table with prefixes of length 1
    dp = [[0] * 10 for _ in range(K)]
    for i in range(10):
        dp[0][i] = 1

    # Calculate DP table for prefixes of length 2 to N
    for i in range(1, N):
        dp_new = [[0] * 10 for _ in range(K)]
        for j in range(10):
            for k in range(K):
                for l in range(10):
                    if k == 0:
                        dp_new[k][(j+l)%K] += dp[k][j]
                    else:
                        if (j+l)%K == k:
                            dp_new[k][(j+l)%K] += dp[k-1][j]
        dp = dp_new

    # Sum up all counts for valid N digit numbers
    count = 0
    for i in range(K):
        count += dp[i][0]

    return count

This code uses a 2D DP table to store the counts of N digit numbers for each possible prefix and running sum. The time complexity of this code is O(N * K^2) and the space complexity is O(K^2).