# Leetcode – Maximum Score After Splitting a String Solution

Leetcode is a well-known platform for honing coding and problem-solving skills, often used for interview preparation. One such problem that has grabbed attention is the “Maximum Score After Splitting a String” problem. This problem is generally classified under the array and string manipulation categories, requiring a combination of insights to solve efficiently.

This in-depth article will cover:

1. Problem Statement & Examples
2. Brute-force Approach
3. Optimized Approach
4. Python Code Implementations
5. Test Cases and Runtime Analysis
6. Conclusion

## 1. Problem Statement & Examples

### Problem Statement

Given a string s of zeros and ones, you need to return the maximum score after splitting the string into two non-empty parts such that the number of zeros on the left part and the number of ones on the right part is maximized.

Example 1:

Input: s = "0111001"
Output: 4
Explanation:
Splitting at index 3 results in two parts: "011" and "1001".
Number of zeros in the left part = 0
Number of ones in the right part = 4
Total score = 0 + 4 = 4

Example 2:

Input: s = "00111"
Output: 3
Explanation:
Splitting at index 2 results in two parts: "00" and "111".
Number of zeros in the left part = 2
Number of ones in the right part = 1
Total score = 2 + 1 = 3

## 2. Brute-force Approach

A straightforward way to solve this problem is to:

1. Iterate over the string, keeping a count of zeros and ones.
2. Try every possible splitting point, calculating the score for each.
3. Return the maximum score.

However, this approach has a time complexity of O(n^2), which is inefficient for large strings.

## 3. Optimized Approach

You can optimize the solution using a single pass through the string:

1. Calculate the total counts of zeros (total_zeros) and ones (total_ones) first.
2. Initialize variables left_zeros and left_ones to keep track of the zeros and ones on the left part as you iterate.
3. Loop through the string to find the score at each split point.

This approach has a time complexity of O(n), which is much better.

## 4. Python Code Implementations

### Brute-force Solution

def maxScore(s: str) -> int:
max_score = 0
for i in range(1, len(s)):
left, right = s[:i], s[i:]
score = left.count('0') + right.count('1')
max_score = max(max_score, score)
return max_score

### Optimized Solution

def maxScore(s: str) -> int:
total_zeros, total_ones = s.count('0'), s.count('1')
max_score, left_zeros, left_ones = 0, 0, 0

for i in range(len(s) - 1):
if s[i] == '0':
left_zeros += 1
else:
left_ones += 1

score = left_zeros + (total_ones - left_ones)
max_score = max(max_score, score)

return max_score

## 5. Test Cases and Runtime Analysis

Both solutions pass the LeetCode test cases, but the optimized solution is much faster.

• Brute-force: O(n^2)
• Optimized: O(n)

## 6. Conclusion

The “Maximum Score After Splitting a String” problem is a compelling task that tests your string manipulation and problem-solving skills. Although a brute-force approach is straightforward to implement, it’s not efficient for large datasets. The optimized O(n) solution is better suited for tackling this problem effectively.