# Count of substrings that start and end with 1 in given Binary String

• Difficulty Level : Easy
• Last Updated : 20 Jan, 2023

Given a binary string, count the number of substrings that start and end with 1.

Examples:

Input: “00100101”
Output: 3
Explanation: three substrings are “1001”, “100101” and “101”

Input: “1001”
Output: 1
Explanation: one substring “1001”

Recommended Practice

## Count of substrings that start and end with 1 in given Binary String using Nested Loop:

A Simple Solution is to run two loops. Outer loops pick every 1 as a starting point and the inner loop searches for ending 1 and increments count whenever it finds 1.

Below is the implementation of above approach:

## C++

 `// A simple C++ program to count number of` `// substrings starting and ending with 1` `#include `   `using` `namespace` `std;`   `int` `countSubStr(``char` `str[])` `{` `    ``int` `res = 0; ``// Initialize result`   `    ``// Pick a starting point` `    ``for` `(``int` `i = 0; str[i] != ``'\0'``; i++) {` `        ``if` `(str[i] == ``'1'``) {` `            ``// Search for all possible ending point` `            ``for` `(``int` `j = i + 1; str[j] != ``'\0'``; j++)` `                ``if` `(str[j] == ``'1'``)` `                    ``res++;` `        ``}` `    ``}` `    ``return` `res;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``char` `str[] = ``"00100101"``;` `    ``cout << countSubStr(str);` `    ``return` `0;` `}`

## Java

 `// A simple Java program to count number of` `// substrings starting and ending with 1`   `class` `CountSubString {` `    ``int` `countSubStr(``char` `str[], ``int` `n)` `    ``{` `        ``int` `res = ``0``; ``// Initialize result`   `        ``// Pick a starting point` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``if` `(str[i] == ``'1'``) {` `                ``// Search for all possible ending point` `                ``for` `(``int` `j = i + ``1``; j < n; j++) {` `                    ``if` `(str[j] == ``'1'``)` `                        ``res++;` `                ``}` `            ``}` `        ``}` `        ``return` `res;` `    ``}`   `    ``// Driver program to test the above function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``CountSubString count = ``new` `CountSubString();` `        ``String string = ``"00100101"``;` `        ``char` `str[] = string.toCharArray();` `        ``int` `n = str.length;` `        ``System.out.println(count.countSubStr(str, n));` `    ``}` `}`

## Python3

 `# A simple Python 3 program to count number of` `# substrings starting and ending with 1`     `def` `countSubStr(st, n):`   `    ``# Initialize result` `    ``res ``=` `0`   `   ``# Pick a starting point` `    ``for` `i ``in` `range``(``0``, n):` `        ``if` `(st[i] ``=``=` `'1'``):`   `            ``# Search for all possible ending point` `            ``for` `j ``in` `range``(i``+``1``, n):` `                ``if` `(st[j] ``=``=` `'1'``):` `                    ``res ``=` `res ``+` `1`   `    ``return` `res`     `# Driver program to test above function` `st ``=` `"00100101"` `list``(st)` `n ``=` `len``(st)` `print``(countSubStr(st, n), end``=``"")`     `# This code is contributed` `# by Nikita Tiwari.`

## C#

 `// A simple C# program to count number of` `// substrings starting and ending with 1` `using` `System;`   `class` `GFG {` `    ``public` `virtual` `int` `countSubStr(``char``[] str, ``int` `n)` `    ``{` `        ``int` `res = 0; ``// Initialize result`   `        ``// Pick a starting point` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``if` `(str[i] == ``'1'``) {` `                ``// Search for all possible` `                ``// ending point` `                ``for` `(``int` `j = i + 1; j < n; j++) {` `                    ``if` `(str[j] == ``'1'``) {` `                        ``res++;` `                    ``}` `                ``}` `            ``}` `        ``}` `        ``return` `res;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)` `    ``{` `        ``GFG count = ``new` `GFG();` `        ``string` `s = ``"00100101"``;` `        ``char``[] str = s.ToCharArray();` `        ``int` `n = str.Length;` `        ``Console.WriteLine(count.countSubStr(str, n));` `    ``}` `}`   `// This code is contributed by Shrikant13`

## PHP

 ``

## Javascript

 ``

Output

`3`

Time Complexity: O(N2), Iterating over every character and for
Auxiliary Space: O(1)

## Count of substrings that start and end with 1 in a given Binary String using Subarray count:

We know that if count of 1’s is m, then there will be m * (m – 1) / 2 possible subarrays.

Follow the steps to solve the problem:

• Count the number of 1’s. Let the count of 1’s be m.
• Return m(m-1)/2

Below is the implementation of above approach:

## C++

 `// A O(n) C++ program to count number of` `// substrings starting and ending with 1` `#include `   `using` `namespace` `std;`   `int` `countSubStr(``char` `str[])` `{` `    ``int` `m = 0; ``// Count of 1's in input string`   `    ``// Traverse input string and count of 1's in it` `    ``for` `(``int` `i = 0; str[i] != ``'\0'``; i++) {` `        ``if` `(str[i] == ``'1'``)` `            ``m++;` `    ``}`   `    ``// Return count of possible pairs among m 1's` `    ``return` `m * (m - 1) / 2;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``char` `str[] = ``"00100101"``;` `    ``cout << countSubStr(str);` `    ``return` `0;` `}`

## Java

 `// A O(n) Java program to count number of substrings` `// starting and ending with 1`   `class` `CountSubString {` `    ``int` `countSubStr(``char` `str[], ``int` `n)` `    ``{` `        ``int` `m = ``0``; ``// Count of 1's in input string`   `        ``// Traverse input string and count of 1's in it` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``if` `(str[i] == ``'1'``)` `                ``m++;` `        ``}`   `        ``// Return count of possible pairs among m 1's` `        ``return` `m * (m - ``1``) / ``2``;` `    ``}`   `    ``// Driver program to test the above function` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``CountSubString count = ``new` `CountSubString();` `        ``String string = ``"00100101"``;` `        ``char` `str[] = string.toCharArray();` `        ``int` `n = str.length;` `        ``System.out.println(count.countSubStr(str, n));` `    ``}` `}`

## Python3

 `# A Python3 program to count number of` `# substrings starting and ending with 1`     `def` `countSubStr(st, n):`   `    ``# Count of 1's in input string` `    ``m ``=` `0`   `    ``# Traverse input string and` `    ``# count of 1's in it` `    ``for` `i ``in` `range``(``0``, n):` `        ``if` `(st[i] ``=``=` `'1'``):` `            ``m ``=` `m ``+` `1`   `    ``# Return count of possible` `    ``# pairs among m 1's` `    ``return` `m ``*` `(m ``-` `1``) ``/``/` `2`     `# Driver program to test above function` `st ``=` `"00100101"` `list``(st)` `n ``=` `len``(st)` `print``(countSubStr(st, n), end``=``"")`     `# This code is contributed` `# by Nikita Tiwari.`

## C#

 `// A O(n) C# program to count` `// number of substrings starting` `// and ending with 1` `using` `System;`   `class` `GFG {` `    ``int` `countSubStr(``char``[] str, ``int` `n)` `    ``{` `        ``int` `m = 0; ``// Count of 1's in` `                   ``// input string`   `        ``// Traverse input string and` `        ``// count of 1's in it` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``if` `(str[i] == ``'1'``)` `                ``m++;` `        ``}`   `        ``// Return count of possible` `        ``// pairs among m 1's` `        ``return` `m * (m - 1) / 2;` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``GFG count = ``new` `GFG();` `        ``String strings = ``"00100101"``;` `        ``char``[] str = strings.ToCharArray();` `        ``int` `n = str.Length;` `        ``Console.Write(count.countSubStr(str, n));` `    ``}` `}`   `// This code is contributed by princiraj`

## PHP

 ``

## Javascript

 ``

Output

`3`

Time Complexity: O(N), where n is the length of the string.
Auxiliary Space: O(1).

## Count of substrings that start and end with 1 in given Binary String using Recursion:

This approach is the same as the above approach but here to calculate the count of 1s we use recursion.

Follow the steps to solve the problem:

• Count the number of 1’s using recursion. Let the count of 1’s be m.
• Return m(m-1)/2

Below is the implementation of above approach:

## C++

 `// A O(n) C++ program to count number of` `// substrings starting and ending with 1` `#include ` `using` `namespace` `std;`   `int` `helper(``int` `n, ``char` `str[], ``int` `i)` `{` `    ``// if 'i' is on the last index` `    ``if` `(i == n - 1)` `        ``return` `(str[i] == ``'1'``) ? 1 : 0;`   `    ``// if current char is 1` `    ``// add 1 to the answer` `    ``if` `(str[i] == ``'1'``)` `        ``return` `1 + helper(n, str, i + 1);`   `    ``// if it is zero` `    ``else` `        ``return` `helper(n, str, i + 1);` `}`   `int` `countSubStr(``char` `str[])` `{` `    ``int` `n = ``strlen``(str);` `    ``// counting the number of 1's in the string` `    ``int` `count = helper(n, str, 0);`   `    ``// return the number of combinations` `    ``return` `(count * (count - 1)) / 2;` `}`   `// Driver program to test above function` `int` `main()` `{` `    ``char` `str[] = ``"00100101"``;` `    ``cout << countSubStr(str);` `    ``return` `0;` `}`   `// this code is contributed by rajdeep999`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;`   `class` `GFG {` `  ``static` `int` `helper(``int` `n, ``char` `str[], ``int` `i)` `  ``{` `    ``// if 'i' is on the last index` `    ``if` `(i == n - ``1``)` `      ``return` `(str[i] == ``'1'``) ? ``1` `: ``0``;`   `    ``// if current char is 1` `    ``// add 1 to the answer` `    ``if` `(str[i] == ``'1'``)` `      ``return` `1` `+ helper(n, str, i + ``1``);`   `    ``// if it is zero` `    ``else` `      ``return` `helper(n, str, i + ``1``);` `  ``}`   `  ``static` `int` `countSubStr(``char` `str[])` `  ``{` `    ``int` `n = str.length;` `    ``// counting the number of 1's in the string` `    ``int` `count = helper(n, str, ``0``);`   `    ``// return the number of combinations` `    ``return` `(count * (count - ``1``)) / ``2``;` `  ``}`   `  ``public` `static` `void` `main (String[] args) {` `    ``char` `str[] = ``"00100101"``.toCharArray();` `    ``System.out.println(countSubStr(str));` `  ``}` `}`   `// This code is contributed by aadityaburujwale.`

## Python3

 `class` `GFG :` `    ``@staticmethod` `    ``def`  `helper( n,  ``str``,  i) :` `      `  `        ``# if 'i' is on the last index` `        ``if` `(i ``=``=` `n ``-` `1``) :` `            ``return` `1` `if` `(``str``[i] ``=``=` `'1'``) ``else` `0` `          `  `        ``# if current char is 1` `        ``# add 1 to the answer` `        ``if` `(``str``[i] ``=``=` `'1'``) :` `            ``return` `1` `+` `GFG.helper(n, ``str``, i ``+` `1``)` `        ``else` `:` `            ``return` `GFG.helper(n, ``str``, i ``+` `1``)` `    ``@staticmethod` `    ``def`  `countSubStr( ``str``) :` `        ``n ``=` `len``(``str``)` `        `  `        ``# counting the number of 1's in the string` `        ``count ``=` `GFG.helper(n, ``str``, ``0``)` `        `  `        ``# return the number of combinations` `        ``return` `int``((count ``*` `(count ``-` `1``)) ``/` `2``)` `    ``@staticmethod` `    ``def` `main( args) :` `        ``str` `=` `list``(``"00100101"``)` `        ``print``(GFG.countSubStr(``str``))` `    `    `if` `__name__``=``=``"__main__"``:` `    ``GFG.main([])` `    `  `    ``# This code is contributed by aadityaburujwale.`

## C#

 `// Include namespace system` `using` `System;`     `public` `class` `GFG` `{` `    ``public` `static` `int` `helper(``int` `n, ``char``[] str, ``int` `i)` `    ``{` `        ``// if 'i' is on the last index` `        ``if` `(i == n - 1)` `        ``{` `            ``return` `(str[i] == ``'1'``) ? 1 : 0;` `        ``}` `      `  `        ``// if current char is 1` `        ``// add 1 to the answer` `        ``if` `(str[i] == ``'1'``)` `        ``{` `            ``return` `1 + GFG.helper(n, str, i + 1);` `        ``}` `        ``else` `        ``{` `            ``return` `GFG.helper(n, str, i + 1);` `        ``}` `    ``}` `    ``public` `static` `int` `countSubStr(``char``[] str)` `    ``{` `        ``var` `n = str.Length;` `      `  `        ``// counting the number of 1's in the string` `        ``var` `count = GFG.helper(n, str, 0);` `      `  `        ``// return the number of combinations` `        ``return` `(``int``)((count * (count - 1)) / 2);` `    ``}` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``char``[] str = ``"00100101"``.ToCharArray();` `        ``Console.WriteLine(GFG.countSubStr(str));` `    ``}` `}`   `// This code is contributed by aadityaburujwale.`

## Javascript

 `// A O(n) JS program to count number of` `// substrings starting and ending with 1` `function` `helper(n, str, i) ` `{`   `    ``// if 'i' is on the last index` `    ``if` `(i == n - 1) {` `        ``return` `(str[i] == ``'1'``) ? 1 : 0;` `    ``}` `    `  `    ``// if current char is 1` `    ``// add 1 to the answer` `    ``if` `(str[i] == ``'1'``) {` `        ``return` `1 + helper(n, str, i + 1);` `    ``}` `    `  `    ``// if it is zero` `    ``else` `{` `        ``return` `helper(n, str, i + 1);` `    ``}` `}`   `function` `countSubStr(str) {` `    ``let n = str.length;` `    `  `    ``// counting the number of 1's in the string` `    ``let count = helper(n, str, 0);` `    `  `    ``// return the number of combinations` `    ``return` `(count * (count - 1)) / 2;` `}`   `// Driver program to test above function` `console.log(countSubStr(``"00100101"``));`   `// This code is contributed by akashish_`

Output

`3`

Time Complexity: O(N), Traversing over the string of size N
Auxiliary Space: O(N), for recursion call stack

My Personal Notes arrow_drop_up
Related Articles