**π‘ Problem Formulation:** Given a binary string, the task is to write a Python program to find the total number of non-empty substrings that contain only the character ‘1’. For instance, if the input is ‘1101’, the desired output is 4 since the substrings with only 1s are ’11’, ‘1’, ‘1’, and ‘1’.

## Method 1: Using Naive Approach

This method involves checking each substring of the input string to see if it contains only ‘1’s. A nested loop is used to generate all possible substrings, and if a substring contains only ‘1’s, we add to our count. This brute force method is simple but not the most efficient for long strings due to O(n^2) time complexity.

Here’s an example:

def count_substrings(s): count = 0 for i in range(len(s)): for j in range(i+1, len(s)+1): if all(c == '1' for c in s[i:j]): count += 1 return count print(count_substrings('1101'))

Output: `4`

The code snippet defines a function `count_substrings(s)`

which iterates over all possible substrings using two loops. For each substring, it checks if all characters are ‘1’s. If so, it increments the count and returns the final count. However, it can be slow for large input strings due to its quadratic time complexity.

## Method 2: Using Grouping

This method improves efficiency by grouping consecutive ‘1’s using the `itertools.groupby()`

function. This reduces the complexity as we only have to consider groups of ‘1’s, rather than every substring, providing a linear time solution.

Here’s an example:

from itertools import groupby def count_substrings(s): return sum(len(list(g)) * (len(list(g)) + 1) // 2 for k, g in groupby(s) if k == '1') print(count_substrings('1101'))

Output: `4`

The `count_substrings(s)`

function uses `groupby()`

from the `itertools`

module to generate groups of identical consecutive elements. It then calculates the number of substrings in each ‘1’ group with the formula n(n+1)/2 (where n is the length of the group) and sums these up to obtain the total count.

## Method 3: Using Regular Expressions

With regular expressions, we can quickly find all sequences of ‘1’s and calculate the number of substrings for each. The `re`

module provides a concise way to handle string patterns, but may not be as performant as dedicated string algorithms for very long strings.

Here’s an example:

import re def count_substrings(s): return sum(len(m.group(0)) * (len(m.group(0)) + 1) // 2 for m in re.finditer(r'1+', s)) print(count_substrings('1101'))

Output: `4`

The function `count_substrings(s)`

finds all matches for the regular expression `'1+'`

, which indicates one or more consecutive ‘1’s. It then calculates the count of substrings for each match using the same formula as before and aggregates these to get the total. While succinct, regular expressions have overhead and might not be the best choice for simple string operations on large datasets.

## Method 4: Using Mathematical Analysis

This method involves a mathematical insight that directly computes the number of desired substrings based on the lengths of consecutive runs of ‘1’s without checking each substring. It has the benefit of constant time complexity regarding the number of such runs, often making it the fastest method.

Here’s an example:

def count_substrings(s): ones = s.split('0') return sum(len(one) * (len(one) + 1) // 2 for one in ones) print(count_substrings('1101'))

Output: `4`

The `count_substrings(s)`

function splits the string by ‘0’s to get sequences of consecutive ‘1’s. It then uses the same n(n+1)/2 formula to calculate the number of substrings for each sequence of ‘1’s. This method is quick and efficient, especially for strings with clear separation between runs of ‘1’s and ‘0’s.

## Bonus One-Liner Method 5: Using List Comprehension and Map

For a quick-and-dirty one-liner solution, Python’s list comprehension along with `map()`

function can be harnessed to perform the task on a string with clearer separation of ‘1’s sequences.

Here’s an example:

print(sum((x*(x+1))//2 for x in map(len, '1101'.split('0'))))

Output: `4`

The one-liner calculates the sum of the series n(n+1)/2 for each length `x`

of sub-sequences of ‘1’, obtained by splitting the original string by ‘0’s. This method is Pythonic and succinct, but may sacrifice readability for brevity.

## Summary/Discussion

**Method 1: Naive Approach.**This method is simple and straightforward. It works on any string but is inefficient for long strings due to O(n^2) time complexity.**Method 2: Using Grouping.**By utilizing itertools, the function becomes more efficient for larger data sets and stays readable, although dealing with large groups can still be costly.**Method 3: Using Regular Expressions.**Regex offers a concise way to solve the problem and is useful for pattern matching, but incurs extra overhead that can be costly in performance.**Method 4: Mathematical Analysis.**This is generally the most efficient method for large datasets because it translates the problem into a mathematical formula, which is fast to compute.**Bonus Method 5: List Comprehension and Map.**It is a neat one-liner that is very Pythonic and efficient for small to medium-sized strings, but can be less readable and hence less maintainable.