#3340

Easy

auto_awesomeString-driven solution strategy

LeetCode Problem Workspace

Check Balanced String

Determine if a numeric string is balanced by comparing sums of digits at even and odd positions efficiently.

Problem Statement

You are given a string num containing only numeric characters. A string is defined as balanced if the sum of digits at even indices equals the sum at odd indices.

Return true if num meets the balanced condition, otherwise return false. For example, num = "1234" is unbalanced while num = "24123" is balanced.

Examples

Example 1

Input: num = "1234"

Output: false

Example 2

Input: num = "24123"

Output: true

Constraints

2 <= num.length <= 100
num consists of digits only

Solution Approach

Iterate and Sum by Index Parity

Traverse the string character by character, convert each digit to an integer, and add it to an even or odd sum based on its index parity. Finally, compare the two sums to decide if the string is balanced.

Single Pass with Accumulation

Maintain two accumulators for even and odd index sums while iterating once over the string. This ensures O(n) time complexity and minimal space usage.

Avoid Extra Data Structures

Do not store individual digits or use additional arrays. Directly summing digits by index reduces memory overhead and aligns with the string-driven solution pattern.

Complexity Analysis

Metric	Value
Time	Depends on the final approach
Space	Depends on the final approach

Time complexity is O(n) as each character is visited once. Space complexity is O(1) because only two sum variables are needed, independent of string length.

What Interviewers Usually Probe

Checks understanding of string iteration and index handling.
Evaluates ability to implement a numeric check without unnecessary data structures.
Observes awareness of edge cases, such as strings with minimal length or equal digits.

Common Pitfalls or Variants

Common pitfalls

Confusing index parity, summing wrong positions for even vs odd indices.
Converting characters incorrectly, e.g., adding ASCII values instead of integers.
Using extra arrays or lists unnecessarily, increasing space complexity.

Follow-up variants

Balance check on strings with alphabetic characters representing numeric values.
Check balanced condition for longer numeric strings with length up to 10^5.
Modify the definition to consider weighted sums for even and odd positions.

FAQ

What does a balanced string mean in Check Balanced String?

A balanced string has the sum of digits at even indices equal to the sum at odd indices.

How do I efficiently implement this without extra memory?

Use two accumulators for even and odd sums and iterate once through the string, avoiding arrays or lists.

Can the string contain non-digit characters?

No, the input string consists only of digits according to the problem constraints.

Is a string of length 2 always balanced?

Not necessarily; it depends on whether the two digits at index 0 and 1 are equal.

What is the key pattern to recognize for this problem?

The string-driven solution strategy focuses on summing digits by index parity to detect balance efficiently.

terminal

Solution

Solution 1: Simulation

We can use an array $f$ of length $2$ to record the sum of numbers at even indices and odd indices. Then, we traverse the string $\textit{nums}$ and add the numbers to the corresponding positions based on the parity of the indices. Finally, we check whether $f[0]$ is equal to $f[1]$.

1

2

3

4

5

6

class Solution:
    def isBalanced(self, num: str) -> bool:
        f = [0, 0]
        for i, x in enumerate(map(int, num)):
            f[i & 1] += x
        return f[0] == f[1]

Continue Practicing

#3337 total characters in string after transformations ii #3343 count number of balanced permutations #3335 total characters in string after transformations i