# Count of setbits in bitwise OR of all K length substrings of given Binary String

• Last Updated : 08 Mar, 2022

Given a binary string str of length N, the task is to find the number of setbits in the bitwise OR of all the K length substrings of string str.

Examples:

Input: N = 4, K = 3, str = “1111”
Output: 3
Explanation: All 3-sized substrings of S are:
“111” and “111”. The OR of these strings is “111”.
Therefore the number of 1 bits is 3.

Input: N = 4, K = 4, str = “0110”
Output: 2
Explanation: All 4-sized substrings of S are “0110”.
The OR of these strings is “0110”.
Therefore the number of 1 bits is 2.

Approach: The solution of the problem is based on the concept of Sliding window Technique. Follow the steps mentioned below:

• Use sliding window technique and find all substrings of size K.
• Store all substring of size K.(here vector of strings is used).
• Do OR of all strings.
• Count the number of setbits and return.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to make OR two string` `string ORing(string a, string b)` `{` `    ``string ans = ``""``;` `    ``int` `n = a.size();` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(a[i] == ``'1'` `|| b[i] == ``'1'``)` `            ``ans += ``"1"``;` `        ``else` `            ``ans += ``"0"``;` `    ``}` `    ``return` `ans;` `}`   `// Function to check the setbits` `// in OR of all K size substring` `int` `solve(string str, ``int` `N, ``int` `K)` `{` `    ``// Making vector to store answer` `    ``vector v1;` `    ``int` `windowsize = K;` `    ``int` `i = 0;` `    ``int` `j = 0;` `    ``string temp = ``""``;`   `    ``// Using sliding window technique` `    ``while` `(j < N) {` `        ``temp.push_back(str[j]);` `        ``if` `(j - i + 1 < windowsize) {` `            ``j++;` `        ``}` `        ``else` `{` `            ``v1.push_back(temp);` `            ``reverse(temp.begin(), temp.end());` `            ``temp.pop_back();` `            ``reverse(temp.begin(), temp.end());` `            ``i++;` `            ``j++;` `        ``}` `    ``}`   `    ``// OR of all strings which` `    ``// are present in the vector` `    ``string a = v1;` `    ``for` `(``int` `i = 1; i < v1.size(); i++) {` `        ``a = ORing(a, v1[i]);` `    ``}`   `    ``// Counting number of set bit` `    ``int` `count = 0;` `    ``for` `(``int` `i = 0; i < a.size(); i++) {` `        ``if` `(a[i] == ``'1'``) {` `            ``count++;` `        ``}` `    ``}` `    ``return` `count;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `N = 4;` `    ``int` `K = 3;` `    ``string str = ``"1111"``;`   `    ``// Calling function` `    ``cout << solve(str, N, K);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG {`   `  ``// Function to make OR two String` `  ``static` `String ORing(String a, String b) {` `    ``String ans = ``""``;` `    ``int` `n = a.length();` `    ``for` `(``int` `i = ``0``; i < n; i++) {` `      ``if` `(a.charAt(i) == ``'1'` `|| b.charAt(i) == ``'1'``)` `        ``ans += ``"1"``;` `      ``else` `        ``ans += ``"0"``;` `    ``}` `    ``return` `ans;` `  ``}`   `  ``static` `String reverse(String input) {` `    ``char``[] a = input.toCharArray();` `    ``int` `l, r = a.length - ``1``;` `    ``for` `(l = ``0``; l < r; l++, r--) {` `      ``char` `temp = a[l];` `      ``a[l] = a[r];` `      ``a[r] = temp;` `    ``}` `    ``return` `String.valueOf(a);` `  ``}`   `  ``// Function to check the setbits` `  ``// in OR of all K size subString` `  ``static` `int` `solve(String str, ``int` `N, ``int` `K)` `  ``{`   `    ``// Making vector to store answer` `    ``Vector v1 = ``new` `Vector<>();` `    ``int` `windowsize = K;` `    ``int` `i = ``0``;` `    ``int` `j = ``0``;` `    ``String temp = ``""``;`   `    ``// Using sliding window technique` `    ``while` `(j < N) {` `      ``temp += (str.charAt(j));` `      ``if` `(j - i + ``1` `< windowsize) {` `        ``j++;` `      ``} ``else` `{` `        ``v1.add(temp);` `        ``temp = reverse(temp);` `        ``temp = temp.substring(``0``, temp.length() - ``1``);` `        ``temp = reverse(temp);` `        ``i++;` `        ``j++;` `      ``}` `    ``}`   `    ``// OR of all Strings which` `    ``// are present in the vector` `    ``String a = v1.get(``0``);` `    ``for` `(i = ``1``; i < v1.size(); i++) {` `      ``a = ORing(a, v1.get(i));` `    ``}`   `    ``// Counting number of set bit` `    ``int` `count = ``0``;` `    ``for` `(i = ``0``; i < a.length(); i++) {` `      ``if` `(a.charAt(i) == ``'1'``) {` `        ``count++;` `      ``}` `    ``}` `    ``return` `count;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `main(String[] args) {` `    ``int` `N = ``4``;` `    ``int` `K = ``3``;` `    ``String str = ``"1111"``;`   `    ``// Calling function` `    ``System.out.print(solve(str, N, K));` `  ``}` `}`   `// This code is contributed by Rajput-Ji `

## Python3

 `# Python code for the above approach`   `# Function to make OR two string` `def` `ORing(a, b):` `    ``ans ``=` `"";` `    ``n ``=` `len``(a)` `    ``for` `i ``in` `range``(n):` `        ``if` `(a[i] ``=``=` `'1'` `or` `b[i] ``=``=` `'1'``):` `            ``ans ``+``=` `'1'``;` `        ``else``:` `            ``ans ``+``=` `'0'``;` `    `  `    ``return` `list``(ans)`   `# Function to check the setbits` `# in OR of all K size substring` `def` `solve(``str``, N, K):` `  `  `    ``# Making vector to store answer` `    ``v1 ``=` `[];` `    ``windowsize ``=` `K;` `    ``i ``=` `0``;` `    ``j ``=` `0``;` `    ``temp ``=` `[];`   `    ``# Using sliding window technique` `    ``while` `(j < N):` `        ``temp.append(``str``[j]);` `        ``if` `(j ``-` `i ``+` `1` `< windowsize):` `            ``j ``+``=` `1` `        ``else``:` `            ``v1.append(''.join(temp));` `            ``temp.pop(``0``)` `            ``i ``+``=` `1` `            ``j ``+``=` `1` `        `  `    ``# OR of all strings which` `    ``# are present in the vector` `    ``a ``=` `v1[``0``];` `    ``for` `i ``in` `range``(``1``, ``len``(v1)):` `        ``a ``=` `ORing(a, v1[i]);` `    `  `    ``# Counting number of set bit` `    ``count ``=` `0``;` `    ``for` `i ``in` `range``(``len``(a)):` `        ``if` `(a[i] ``=``=` `'1'``):` `            ``count ``=` `count ``+` `1``;` `        `  `    ``return` `count;`   `# Driver code` `N ``=` `4``;`   `K ``=` `3``;` `str` `=` `"1111"``;`   `# Calling function` `print``(solve(``str``, N, K));`   `# This code is contributed by Saurabh Jaiswal`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `public` `class` `GFG {`   `  ``// Function to make OR two String` `  ``static` `String ORing(String a, String b) {` `    ``String ans = ``""``;` `    ``int` `n = a.Length;` `    ``for` `(``int` `i = 0; i < n; i++) {` `      ``if` `(a[i] == ``'1'` `|| b[i] == ``'1'``)` `        ``ans += ``"1"``;` `      ``else` `        ``ans += ``"0"``;` `    ``}` `    ``return` `ans;` `  ``}`   `  ``static` `String reverse(String input) {` `    ``char``[] a = input.ToCharArray();` `    ``int` `l, r = a.Length - 1;` `    ``for` `(l = 0; l < r; l++, r--) {` `      ``char` `temp = a[l];` `      ``a[l] = a[r];` `      ``a[r] = temp;` `    ``}` `    ``return` `String.Join(``""``,a);` `  ``}`   `  ``// Function to check the setbits` `  ``// in OR of all K size subString` `  ``static` `int` `solve(String str, ``int` `N, ``int` `K)` `  ``{`   `    ``// Making vector to store answer` `    ``List v1 = ``new` `List();` `    ``int` `windowsize = K;` `    ``int` `i = 0;` `    ``int` `j = 0;` `    ``String temp = ``""``;`   `    ``// Using sliding window technique` `    ``while` `(j < N) {` `      ``temp += (str[j]);` `      ``if` `(j - i + 1 < windowsize) {` `        ``j++;` `      ``} ``else` `{` `        ``v1.Add(temp);` `        ``temp = reverse(temp);` `        ``temp = temp.Substring(0, temp.Length - 1);` `        ``temp = reverse(temp);` `        ``i++;` `        ``j++;` `      ``}` `    ``}`   `    ``// OR of all Strings which` `    ``// are present in the vector` `    ``String a = v1;` `    ``for` `(i = 1; i < v1.Count; i++) {` `      ``a = ORing(a, v1[i]);` `    ``}`   `    ``// Counting number of set bit` `    ``int` `count = 0;` `    ``for` `(i = 0; i < a.Length; i++) {` `      ``if` `(a[i] == ``'1'``) {` `        ``count++;` `      ``}` `    ``}` `    ``return` `count;` `  ``}`   `  ``// Driver code` `  ``public` `static` `void` `Main(String[] args)` `  ``{` `    ``int` `N = 4;` `    ``int` `K = 3;` `    ``String str = ``"1111"``;`   `    ``// Calling function` `    ``Console.Write(solve(str, N, K));` `  ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`3`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :