You are given a string s consisting of lowercase English letters.

The score of a string is the sum of the positions of its characters in the alphabet, where 'a' = 1, 'b' = 2, ..., 'z' = 26. For example, the score of "abc" is 1 + 2 + 3 = 6.

Your task is to determine whether there exists an index i such that the string can be split into two non-empty substrings s[0..i] and s[(i + 1)..(n - 1)] whose scores are equal.

Return true if such a split exists, otherwise return false.

In other words, you need to check if there is a cutting point in the string where the total score of the left part exactly matches the total score of the right part. Both parts must contain at least one character, so the split cannot happen before the first character or after the last one.

A brute-force way to solve this would be: for every possible split point i, compute the score of the left part s[0..i] and the score of the right part s[(i+1)..(n-1)], then compare them. However, recomputing both sums from scratch at every split point wastes a lot of work, since adjacent split points share almost all of their characters.

The key observation is that the total score of the string never changes. If we call the total score total, then at any split point the left score l and the right score r always satisfy l + r = total.

This means we don't need two separate computations. We can compute total once upfront, then scan the string from left to right. As we pass each character, its value simply moves from the right side to the left side: we add it to l and subtract it from r. After each move, checking whether l == r takes constant time.

This is essentially the prefix sum idea: the left score is a running prefix sum, and the right score is just total - prefix. Each split point is checked in O(1) time, giving an overall O(n) solution with a single pass.

One small detail: we only iterate over the first n - 1 characters, because both parts must be non-empty — placing the last character on the left side would leave the right side empty, which is not a valid split.

Pattern Learn more about Prefix Sum patterns.

The solution uses the Prefix Sum pattern with two running variables — no extra data structures are needed.

Step 1: Compute the total score

First, calculate the score of the entire string and store it in r, which initially represents the suffix score (the right part covering the whole string):

r = sum(ord(c) - ord("a") + 1 for c in s)

Here, ord(c) - ord("a") + 1 converts a character to its alphabet position: 'a' becomes 1, 'b' becomes 2, and so on up to 'z' which becomes 26.

We also initialize l = 0, representing the prefix score (the left part, which starts empty).

Step 2: Scan the split points

Traverse the first n - 1 characters from left to right using s[:-1]. We deliberately skip the last character because including it on the left side would leave the right side empty, violating the non-empty requirement.

For each character c:

1. Compute its value x = ord(c) - ord("a") + 1.
2. Move the character from the right side to the left side:
   • l += x — the prefix score grows.
   • r -= x — the suffix score shrinks.
3. Check the balance condition: if l == r, a valid split exists at the current position, so return True immediately.

for c in s[:-1]:
    x = ord(c) - ord("a") + 1
    l += x
    r -= x
    if l == r:
        return True

Step 3: No valid split found

If the loop finishes without l ever equaling r, no split point satisfies the condition, so return False.

Why this works

The invariant l + r = total holds at every step, since each character's value is transferred from r to l exactly once. Checking l == r at split point i is therefore equivalent to checking whether the prefix score equals total / 2 — but by maintaining both variables explicitly, we avoid any concerns about whether total is even and keep the logic straightforward.

Complexity Analysis

• Time complexity: O(n) — one pass to compute the total score, and one pass to check all split points, where n is the length of s.
• Space complexity: O(1) — only two integer variables l and r are maintained, regardless of input size.