Abstract / Summary

Check if an array can be split into two nonempty parts with equal average values.

Note

The full problem description, including helpful examples, can be found on LeetCode.

This problem is ranked as

and has an acceptance rate of about 35% (90k+ submissions).

Typical patterns to solve this problem:

• Array
• Dynamic Programming
• Greedy

Every single line of code was written by me, 100% from scratch, between August 2023 and August 2024.
However, two years later I set up this website and used various AI tools to generate most of the walkthrough / explanations below.

See this dedicated page for more details.

Overview

The provided Solution class implements a single method canSplitArray. The method receives a list of integers nums and an integer threshold m. Its purpose is to determine whether the array can be reduced, by repeatedly removing elements from either end, until only two adjacent elements remain whose sum meets or exceeds the threshold m. The implementation returns a Boolean value indicating the feasibility of such a reduction.

Key Steps

The first logical step checks the size of the input array. If the array contains two or fewer elements, the method immediately returns True. This reflects the fact that no chopping is required when the array is already at the minimal size needed for the final condition.

if len(nums) <= 2:
    return True

When the array is larger, the method proceeds to evaluate every pair of consecutive elements. It uses the built-in any function together with a generator expression that iterates over the zipped view of the list and its tail. For each adjacent pair (a, b), it computes the sum a + b and checks whether this sum is at least m. The any function short-circuits as soon as it encounters a pair satisfying the condition, returning True; otherwise it exhausts the iterator and returns False.

return any(a + b >= m for a, b in zip(nums, nums[1:]))

The combination of the early size check and the generator expression constitutes the entire decision logic of the method.

Edge Cases Handled

The early size check implicitly covers several edge scenarios. An empty list (nums = []) has a length of zero, which satisfies the len(nums) <= 2 condition, leading the method to return True. This aligns with the interpretation that no elements need to be removed and the final condition is vacuously satisfied. A single-element list (nums = [x]) also triggers the same branch, returning True because there are no adjacent pairs to evaluate, and the problem definition permits immediate success when the array size is already at or below two.

When the list contains exactly two elements, the method again returns True without examining their sum. This reflects the specification that the final split can be performed as long as the array size is two, regardless of whether the sum meets the threshold. The subsequent any expression is therefore never executed for arrays of size two or less, avoiding unnecessary computation.

For arrays longer than two elements, the generator expression gracefully handles the situation where no adjacent pair reaches the threshold. In that case, any evaluates the entire sequence of pairs and ultimately yields False, indicating that no sequence of end-chops can produce a qualifying final pair.

Performance Optimizations

The implementation leverages short-circuit evaluation in two distinct ways. First, the size check len(nums) <= 2 provides an immediate answer for small inputs, bypassing any iteration. This eliminates overhead for trivial cases and prevents the creation of intermediate iterators.

Second, the use of a generator expression inside any ensures that pairs are generated lazily. The zip function pairs each element with its immediate successor without constructing a full list of tuples. As soon as a qualifying pair is found, any stops further iteration, avoiding unnecessary sum calculations for the remainder of the array. This on-the-fly evaluation reduces both memory footprint and processing time for typical inputs where a qualifying pair appears early in the sequence.

The overall flow avoids explicit loops, conditional branches inside the loop, or auxiliary data structures, resulting in a compact and efficient execution path that directly maps the problem statement to Python’s high-level constructs.

Imagine you have a long row of building blocks sitting on the floor. The goal is to break this row into smaller pieces until every piece is just a single block by itself.

The code looks at the blocks to see if there is any place where two neighbors are strong enough to help with this task. When two blocks side by side add up to a big enough number, they act like a magic key. This key allows the row to be broken down one by one until only single blocks remain. If the row is already very tiny with only one or two blocks, it is already simple to manage. If there is at least one pair of best friends sitting next to each other who are strong enough, the whole row can be taken apart piece by piece.

Several LLMs ranked my code quality on a scale from 1 (very poor) to 10 (outstanding):

Time: linear
As a rule of thumb, the maximum input size for one second execution time is

• factorial: up to 10 elements
• exponential: up to 20 elements
• polynomial: a few thousand elements
• loglinear: up to 100,000 elements
• linear: a few million elements
• logarithmic: a billion elements
• constant: practically unlimited

I wrote a basic crawler to find other solutions to that problem.
Obviously, I did that after I solved the problem myself.

In general, AlgoMonster and WalkCCC solutions are high-quality and always worth a look.
I haven't checked most of the other solutions, but they might be helpful as well.

And of course, the LeetCode forum is always a good place (or even the best) to look for alternative approaches.

(click on a column header to sort the table)

	author
author	solutions
www	AlgoMonster	C++		Java		Python		TS
	WalkCCC	C++		Java		Python
	leetcode.ca	C++		Java	Go	Python	Rust	TS
	Progiez	C++		Java		Python
github	charles-wangkai			Java
	everthis		JS
	fsq	C++
	wisdompeak	C++
AlgoMonster	C++, Python, Java, TypeScript
WalkCCC	C++, Python, Java
leetcode.ca	C++, Go, Java, Python, Rust, TypeScript
Progiez	C++, Java, Python
charles-wangkai	Java
everthis	JavaScript
fsq	C++
wisdompeak	C++

There are a few extra pages giving you some insights into my setup:

• Tech Stack - my development environment and tools
• AI - how AI helped me create this website (NOT solving the problems)
• Progress - progression over time
• Quality - code quality