# Count of Binary Strings of length at most N with set bit count as multiple of K

• Difficulty Level : Hard
• Last Updated : 28 Oct, 2021

Given two integers N and K, the task is to find the count of binary strings of at most N length that can be formed such that the count of consecutive 1‘s is always a multiple of K.

Example:

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: N = 3, K = 2
Output: 6
Explanation: Binary strings of atmost N length containing consecutive 1’s as a multiple of K are as follows:

1. Length 1: “0”, contains 0 consecutive 1.
2. Length 2: “00”, “11”, contains 0 and 2 consecutive 1’s respectively.
3. Length 3: “000”, “011”, “110”, contains 0 and two different combinations of 2 consecutive 1’s respectively.

So, total number of strings that can be formed is 6.

Input: N = 5, K = 4
Output: 8

Approach: The given problem can be solved with the help of Dynamic Programming using memoization. Follow the below steps to solve the given problem:

• Create a recursive function cntStrings(N, K), which returns the number of strings of N length having the consecutive 1’s as multiples of K. This can be done by assigning 1 to the next K consecutive indices from the current index and recursively calling for the remaining string or assigning 0 to the current index and recursively calling for the remaining string.
• Create an array dp[] which stores the memorized values of the above recursive function.
• Call the function cntStrings(i, K) for all possible values of i in the range [1, N] and store their sum in a variable cnt.
• The value stored in cnt is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `int` `dp;` `// Recursive function to find the count``// of valid binary strings of length n``int` `cntString(``int` `n, ``int` `k)``{``    ``// Base Case``    ``if` `(n == 0) {``        ``return` `1;``    ``}` `    ``// If current value is already calculated``    ``if` `(dp[n] != -1) {``        ``return` `dp[n];``    ``}` `    ``// Stores the current answer``    ``int` `ans = 0;` `    ``// Case for element at next k indices as 1``    ``if` `(n >= k) {``        ``ans += cntString(n - k, k);``    ``}` `    ``// Case for element at current index as 0``    ``ans += cntString(n - 1, k);` `    ``// Return ans with storing it in dp[]``    ``return` `dp[n] = ans;``}` `// Function to find the count of valid``// binary strings of atmost N length``int` `cntStringAll(``int` `N, ``int` `K)``{``    ``// Initializing all elements with -1``    ``memset``(dp, -1, ``sizeof``(dp));` `    ``// Stores the final answer``    ``int` `cnt = 0;` `    ``// Iterate and calculate the total``    ``// possible binary strings of each``    ``// length in the range [1, N]``    ``for` `(``int` `i = 1; i <= N; i++) {``        ``cnt += cntString(i, K);``    ``}` `    ``// Return Answer``    ``return` `cnt;``}` `// Driver Code``int` `main()``{``    ``int` `N = 5;``    ``int` `K = 4;` `    ``cout << cntStringAll(N, K);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``class` `GFG {` `    ``static` `int` `dp[] = ``new` `int``[``1001``];` `    ``// Recursive function to find the count``    ``// of valid binary strings of length n``    ``static` `int` `cntString(``int` `n, ``int` `k)``    ``{``        ``// Base Case``        ``if` `(n == ``0``) {``            ``return` `1``;``        ``}` `        ``// If current value is already calculated``        ``if` `(dp[n] != -``1``) {``            ``return` `dp[n];``        ``}` `        ``// Stores the current answer``        ``int` `ans = ``0``;` `        ``// Case for element at next k indices as 1``        ``if` `(n >= k) {``            ``ans += cntString(n - k, k);``        ``}` `        ``// Case for element at current index as 0``        ``ans += cntString(n - ``1``, k);` `        ``// Return ans with storing it in dp[]``        ``return` `dp[n] = ans;``    ``}` `    ``// Function to find the count of valid``    ``// binary strings of atmost N length``    ``static` `int` `cntStringAll(``int` `N, ``int` `K)``    ``{``        ``// Initializing all elements with -1``        ``for` `(``int` `i = ``0``; i < ``1001``; i++)``            ``dp[i] = -``1``;` `        ``// Stores the final answer``        ``int` `cnt = ``0``;` `        ``// Iterate and calculate the total``        ``// possible binary strings of each``        ``// length in the range [1, N]``        ``for` `(``int` `i = ``1``; i <= N; i++) {``            ``cnt += cntString(i, K);``        ``}` `        ``// Return Answer``        ``return` `cnt;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `N = ``5``;``        ``int` `K = ``4``;` `        ``System.out.println(cntStringAll(N, K));``    ``}``}` `// This code is contributed by dwivediyash`

## Python3

 `# python program for the above approach``dp ``=` `[``-``1` `for` `_ ``in` `range``(``1001``)]` `# Recursive function to find the count``# of valid binary strings of length n``def` `cntString(n, k):` `        ``# Base Case``    ``if` `(n ``=``=` `0``):``        ``return` `1` `        ``# If current value is already calculated``    ``if` `(dp[n] !``=` `-``1``):``        ``return` `dp[n]` `        ``# Stores the current answer``    ``ans ``=` `0` `    ``# Case for element at next k indices as 1``    ``if` `(n >``=` `k):``        ``ans ``+``=` `cntString(n ``-` `k, k)` `        ``# Case for element at current index as 0``    ``ans ``+``=` `cntString(n ``-` `1``, k)` `    ``# Return ans with storing it in dp[]``    ``dp[n] ``=` `ans` `    ``return` `dp[n]`  `# Function to find the count of valid``# binary strings of atmost N length``def` `cntStringAll(N, K):` `        ``# Stores the final answer``    ``cnt ``=` `0` `    ``# Iterate and calculate the total``    ``# possible binary strings of each``    ``# length in the range [1, N]``    ``for` `i ``in` `range``(``1``, N ``+` `1``):``        ``cnt ``+``=` `cntString(i, K)` `    ``# Return Answer``    ``return` `cnt` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `5``    ``K ``=` `4` `    ``print``(cntStringAll(N, K))` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG``{` `    ``static` `int` `[]dp = ``new` `int``;` `    ``// Recursive function to find the count``    ``// of valid binary strings of length n``    ``static` `int` `cntString(``int` `n, ``int` `k)``    ``{``      ` `        ``// Base Case``        ``if` `(n == 0) {``            ``return` `1;``        ``}` `        ``// If current value is already calculated``        ``if` `(dp[n] != -1) {``            ``return` `dp[n];``        ``}` `        ``// Stores the current answer``        ``int` `ans = 0;` `        ``// Case for element at next k indices as 1``        ``if` `(n >= k) {``            ``ans += cntString(n - k, k);``        ``}` `        ``// Case for element at current index as 0``        ``ans += cntString(n - 1, k);` `        ``// Return ans with storing it in dp[]``        ``return` `dp[n] = ans;``    ``}` `    ``// Function to find the count of valid``    ``// binary strings of atmost N length``    ``static` `int` `cntStringAll(``int` `N, ``int` `K)``    ``{``      ` `        ``// Initializing all elements with -1``        ``for` `(``int` `i = 0; i < 1001; i++)``            ``dp[i] = -1;` `        ``// Stores the final answer``        ``int` `cnt = 0;` `        ``// Iterate and calculate the total``        ``// possible binary strings of each``        ``// length in the range [1, N]``        ``for` `(``int` `i = 1; i <= N; i++) {``            ``cnt += cntString(i, K);``        ``}` `        ``// Return Answer``        ``return` `cnt;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int` `N = 5;``        ``int` `K = 4;` `        ``Console.WriteLine(cntStringAll(N, K));``    ``}``}` `// This code is contributed by AnkThon`

## Javascript

 ``
Output
`8`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up