# Longest substring of 0s in a string formed by k concatenations

• Difficulty Level : Medium
• Last Updated : 17 Aug, 2022

Given a binary string of length n and an integer k. Consider another string T which is formed by concatenating the given binary string k times. The task is to print the maximum size of a substring of T containing only zeroes.

Examples:

Input: str = 110010, k = 3
Output:
str = 110010 T = 110010110010110010(formed after 3 times concatenating str). So, the maximum size of a substring of T(110010110010110010) containing only zeroes is 2.

Input: str = 00100110, k = 5
Output:
Here, str = 00100110, T = 0010011000100110001001100010011000100110. So, the maximum size of a substring of T containing only zeroes is 3.

A Naive approach is to concatenate K copies of string and traverse through all the elements and count maximum size of substring containing only zeroes.

Efficient Approach:

There is no need to concatenate K copies.

1. If string contains only zeroes then the answer is length_of_string * K.
2. If string is comprised of both zeroes and ones, then the answer is either the maximum length of a substring of string containing only zeroes, or the sum of the length of the prefix of A containing only zeroes and the length of the suffix of string containing only zeroes.
3. One thing to keep note of is that if K=1, then there is no need for prefix and suffix check.

Implementation:

## C++

 `// C++ code to find maximum length``// of substring that contains only 0's``#include ``using` `namespace` `std;` `// Function to calculate maximum length``// of substring containing only zero``int` `subzero(string str, ``int` `k)``{``    ``int` `ans = 0, curr = 0;``    ``int` `len = str.length();` `    ``// loop to first calculate longest substring``    ``// in string``    ``for` `(``int` `i = 0; i < len; ++i) {``        ``if` `(str[i] == ``'0'``)``            ``curr++;``        ``else``            ``curr = 0;` `        ``ans = max(ans, curr);``    ``}` `    ``// if all elements in string  are '0'``    ``if` `(ans == len)``        ``return` `len * k;` `    ``// Else, find size of prefix and``    ``// suffix containing only zeroes``    ``else` `{``        ``int` `pre = 0, suff = 0;` `        ``// Calculate prefix containing only zeroes``        ``for` `(``int` `i = 0; i < len; i++) {``            ``if` `(str[i] == ``'0'``)``                ``pre++;``            ``else``                ``break``;``        ``}` `        ``// Calculate suffix containing only zeroes``        ``for` `(``int` `i = len - 1; i >= 0; i--) {``            ``if` `(str[i] == ``'0'``)``                ``suff++;``            ``else``                ``break``;``        ``}` `        ``// if k<=1 then there is no need to take``        ``// prefix + suffix into account``        ``if` `(k > 1)``            ``ans = max(ans, pre + suff);``        ``return` `ans;``    ``}``}` `// Drivers code``int` `main()``{``    ``string str = ``"00100110"``;``    ``int` `k = 5;``    ``cout << subzero(str, k);``    ``return` `0;``}`

## Java

 `// Java code to find maximum length``// of substring that contains only 0's``import` `java.io.*;``import` `java.util.*;``import` `java.lang.*;` `class` `GfG {``    ` `    ``// Function to calculate maximum length``    ``// of substring containing only zero``    ``public` `static` `int` `subzero(String s, ``int` `k)``    ``{``        ``int` `ans = ``0``, curr = ``0``;``        ``int` `len = s.length();``        ``char``[] str = s.toCharArray();``    ` `        ``// loop to first calculate longest``        ``// substring in string``        ``for` `(``int` `i = ``0``; i < len; ++i) {``            ``if` `(str[i] == ``'0'``)``                ``curr++;``            ``else``                ``curr = ``0``;``    ` `            ``ans = Math.max(ans, curr);``        ``}``    ` `        ``// if all elements in string are '0'``        ``if` `(ans == len)``            ``return` `len * k;``    ` `        ``// Else, find size of prefix and``        ``// suffix containing only zeroes``        ``else` `{``            ``int` `pre = ``0``, suff = ``0``;``    ` `            ``// Calculate prefix containing``            ``// only zeroes``            ``for` `(``int` `i = ``0``; i < len; i++) {``                ``if` `(str[i] == ``'0'``)``                    ``pre++;``                ``else``                    ``break``;``            ``}``    ` `            ``// Calculate suffix containing``            ``// only zeroes``            ``for` `(``int` `i = len - ``1``; i >= ``0``; i--)``            ``{``                ``if` `(str[i] == ``'0'``)``                    ``suff++;``                ``else``                    ``break``;``            ``}``    ` `            ``// if k<=1 then there is no need to``            ``// take prefix + suffix into account``            ``if` `(k > ``1``)``                ``ans = Math.max(ans, pre + suff);``            ``return` `ans;``        ``}``    ``}``    ` `    ``// Drivers code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``String str = ``"00100110"``;``        ``int` `k = ``5``;``        ``System.out.println(subzero(str, k));``    ``}``}` `// This code is contributed by Sagar Shukla`

## Python

 `# Python code calculate maximum length of substring``# containing only zero``def` `subzero(``str``, k):``    ``ans ``=` `0``    ``curr ``=` `0``    ``n ``=` `len``(``str``)` `    ``# loop to calculate longest substring in string``    ``# containing 0's``    ``for` `i ``in` `str``:``        ``if` `(i ``=``=``'0'``):``            ``curr``+``=` `1``    ` `        ``else``:``            ``curr ``=` `0``        ``ans ``=` `max``(ans, curr)``    ``# if all elements in string a are '0'``    ``if` `(ans ``=``=` `n):``        ``print``(n ``*` `k)``        ``return``    ` `    ``# Else, find prefix and suffix containing``    ``# only zeroes``    ``else``:``        ``pre ``=` `suff ``=` `0``        ` `        ``# Calculate length of the  prefix containing``        ``# only zeroes``        ``for` `i ``in` `str``:``            ``if``(i ``=``=``'0'``):``                ``pre``+``=` `1``            ``else``:``                ``break``                ` `        ``# Calculate length of the suffix containing``        ``# only zeroes``        ``for` `i ``in` `range``(n``-``1``, ``-``1``, ``-``1``):``            ``if``(``str``[i]``=``=``'0'``):``                ``suff``+``=` `1``            ``else``:``                ``break``                ` `    ``# if k<= 1, no need to take suffix + prefix``    ``# into account``    ``if` `(k > ``1``):``        ``ans ``=` `max``(ans, pre ``+` `suff)``    ``print``(ans)``    ``return``    ` `# Driver program to test above function``k ``=` `5``str` `=``'00100110'``subzero(``str``, k)`

## C#

 `// C# code to find maximum length``// of substring that contains only 0's``using` `System;` `class` `GFG``{` `// Function to calculate maximum length``// of substring containing only zero``public` `static` `int` `subzero(String s, ``int` `k)``{``    ``int` `ans = 0, curr = 0;``    ``int` `len = s.Length;``    ``char``[] str = s.ToCharArray();` `    ``// loop to first calculate longest``    ``// substring in string``    ``for` `(``int` `i = 0; i < len; ++i)``    ``{``        ``if` `(str[i] == ``'0'``)``            ``curr++;``        ``else``            ``curr = 0;` `        ``ans = Math.Max(ans, curr);``    ``}` `    ``// if all elements in string are '0'``    ``if` `(ans == len)``        ``return` `len * k;` `    ``// Else, find size of prefix and``    ``// suffix containing only zeroes``    ``else``    ``{``        ``int` `pre = 0, suff = 0;` `        ``// Calculate prefix containing``        ``// only zeroes``        ``for` `(``int` `i = 0; i < len; i++)``        ``{``            ``if` `(str[i] == ``'0'``)``                ``pre++;``            ``else``                ``break``;``        ``}` `        ``// Calculate suffix containing``        ``// only zeroes``        ``for` `(``int` `i = len - 1; i >= 0; i--)``        ``{``            ``if` `(str[i] == ``'0'``)``                ``suff++;``            ``else``                ``break``;``        ``}` `        ``// if k<=1 then there is no need to``        ``// take prefix + suffix into account``        ``if` `(k > 1)``            ``ans = Math.Max(ans, pre + suff);``        ``return` `ans;``    ``}``}` `// Driver code``public` `static` `void` `Main()``{``    ``String str = ``"00100110"``;``    ``int` `k = 5;``    ``Console.Write(subzero(str, k));``}``}` `// This code is contributed by PrinciRaj1992`

## PHP

 `= 0; ``\$i``--)``        ``{``            ``if` `(``\$str``[``\$i``] == ``'0'``)``                ``\$suff``++;``            ``else``                ``break``;``        ``}` `        ``// if k<=1 then there is no need to take``        ``// prefix + suffix into account``        ``if` `(``\$k` `> 1)``            ``\$ans` `= max(``\$ans``, ``\$pre` `+ ``\$suff``);``        ``return` `\$ans``;``    ``}``}` `// Driver code``\$str` `= ``"00100110"``;``\$k` `= 5;``echo` `subzero(``\$str``, ``\$k``);` `// This code is contributed by ita_c``?>`

## Javascript

 ``

Output

`3`

Complexity Analysis:

• Time Complexity: O(n) as there is a single loop used in the subzero() function.
• Space Complexity: O(1) as there is no extra space used.

My Personal Notes arrow_drop_up